Manage events entities is pretty easy. You define few informations like a subject, a content, and maybe the most important, dates (a start and a end date of course).
You’re ready to create calendar or timeline features. Baooom! Now you need to be able to create recurrent event ! And everything is going to break.
I’ve work on this kind of feature, and here are my small advices
How to Write Highly Scalable and Maintainable JavaScript: Modules
A Gantt chart is mainly used in project management. It is a bar chart, designed by Henry Gantt, that shows a project schedule. Gantt chart illustrates elements contained in the work breakdown structure (WBS) of the project. Gantt charts usually show the start and finish dates of WBS elements and also show the dependency relationships between them.
public class Rectangle
{
public int Length { get; set; }
public int Height { get; set; }
public void Grow(int length, int height)
{
Length += length;
Height += height;
}
}
Rectangle r = new Rectangle();
r.Length = 5;
r.Height = 10;
r.Grow(10, 10);// r.Length is 15, r.Height is 20, same instance of r // After
public class ImmutableRectangle
{
int Length { get; }
int Height { get; }
public ImmutableRectangle(int length, int height)
{
Length = length;
Height = height;
}
public ImmutableRectangle Grow(int length, int height) =>
new ImmutableRectangle(Length + length, Height + height);
}
ImmutableRectangle r = new ImmutableRectangle(5, 10);
r = r.Grow(10, 10);// r.Length is 15, r.Height is 20, is a new instance of r public static void Main()
{
Console.WriteLine(GetSalutation(DateTime.Now.Hour));
}
// imparitive, mutates state to produce a result
/*public static string GetSalutation(int hour)
{
string salutation; // placeholder value
if (hour < 12)
salutation = "Good Morning";
else
salutation = "Good Afternoon";
return salutation; // return mutated variable
}*/
public static string GetSalutation(int hour) => hour < 12 ? "Good Morning" : "Good Afternoon"; public static int Count<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
int count = 0;
foreach (TSource element in source)
{
checked
{
if (predicate(element))
{
count++;
}
}
}
return count;
} public static class Extensions
{
public static Func<T, TReturn2> Compose<T, TReturn1, TReturn2>(this Func<TReturn1, TReturn2> func1, Func<T, TReturn1> func2)
{
return x => func1(func2(x));
}
}
public class Program
{
public static void Main(string[] args)
{
Func<int, int> square = (x) => x * x;
Func<int, int> negate = x => x * -1;
Func<int, string> toString = s => s.ToString();
Func<int, string> squareNegateThenToString = toString.Compose(negate).Compose(square);
Console.WriteLine(squareNegateThenToString(2));
}
} string str = new StringBuilder()
.Append("Hello ")
.Append("World ")
.ToString()
.TrimEnd()
.ToUpper(); public static class Extensions
{
public static StringBuilder AppendWhen(this StringBuilder sb, string value, bool predicate) => predicate ? sb.Append(value) : sb;
}
public class Program
{
public static void Main(string[] args)
{
// Extends the StringBuilder class to accept a predicate
string htmlButton = new StringBuilder().Append("<button").AppendWhen(" disabled", false).Append(">Click me</button>").ToString();
}
} public static void Main()
{
int[] a = { 1, 2, 3, 4, 5 };
foreach (int n in GreaterThan(a, 3))
{
Console.WriteLine(n);
}
}
/*public static IEnumerable<int> GreaterThan(int[] arr, int gt)
{
List<int> temp = new List<int>();
foreach (int n in arr)
{
if (n > gt) temp.Add(n);
}
return temp;
}*/
public static IEnumerable<int> GreaterThan(int[] arr, int gt)
{
foreach (int n in arr)
{
if (n > gt) yield return n;
}
} List<int> collection = new List<int> { 1, 2, 3, 4, 5 };
// Imparative style of programming is verbose
List<int> results = new List<int>();
foreach(var num in collection)
{
if (num % 2 != 0) results.Add(num);
}
// Declarative is terse and beautiful
var results = collection.Where(num => num % 2 != 0); | Collection | توضیحات |
| ConcurrentDictionary | پیاده سازی thread safe از دیکشنری key-value |
| ConcurrentQueue | پیاده سازی thread safe از صف (اولین ورودی ، اولین خروجی) |
| ConcurrentStack | پیاده سازی thread safe از پشته (آخرین ورودی ، اولین خروجی) |
| ConcurrentBag | پیاده سازی thread safe از لیست نامرتب |
.NotSupportedException: The method 'Max' is not supported
This topic provides information about the way in which LINQ queries are composed and executed when you are using the WCF Data Services client and limitations of using LINQ to query a data service that implements the Open Data Protocol (OData). For more information about composing and executing queries against an OData-based data service, see Querying the Data Service (WCF Data Services). Composing LINQ Queries LINQ enables you to compose queries against a collection of objects that implements IEnumerable. Both the Add Service Reference dialog box in Visual Studio and the DataSvcUtil.exe tool are used to generate a representation of an OData service as an entity container class that inherits from DataServiceContext, as well as objects that represent the entities returned in feeds. These tools also generate properties on the entity container class for the collections that are exposed as feeds by the service. Each of these properties of the class that encapsulates the data service return a DataServiceQuery. Because the DataServiceQuery class implements the IQueryable interface defined by LINQ, the WCF Data Services you can compose a LINQ query against feeds exposed by the data service, which are translated by the client library into a query request URI that is sent to the data service on execution. Note: The set of queries expressible in the LINQ syntax is broader than those enabled in the URI syntax that is used by OData data services. A NotSupportedException is raised when the query cannot be mapped to a URI in the target data service. For more information, see the Unsupported LINQ Methods in this topic.
The Open XML SDK provides tools for working with Office Word, Excel, and PowerPoint documents. It supports scenarios such as:
Graph Data Processing with SQL Server 2017
