public static void NonStreamingOperators()
{
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
}
static void Main(string[] args)
{
var movies = new List <Movie> {
new Movie {
Title = "The Dark Knight", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "The King's Speech", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "Casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "Star war V", Rating = 8.7f, Year = 1980
}
};
var query = movies.Where(m => m.Year > 2000);
foreach (var item in query)
{
Console.WriteLine(item.Title);
}
Console.WriteLine("***********************************");
query = movies.Filter(m => m.Year > 2000);
foreach (var item in query)
{
Console.WriteLine(item.Title);
}
Console.WriteLine("***********************************");
query = movies.Filter2(m => m.Year > 2000);
foreach (var item in query)
{
Console.WriteLine(item.Title);
}
Console.WriteLine("***********************************");
query = movies.Filter2(m => m.Year > 2000).ToList();// will run query once to get results
Console.WriteLine(query.Count());
var enumerator = query.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
Console.WriteLine("***********************************");
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10);
foreach (var item in numbers)
{
Console.WriteLine(item);
}
}
static void Main(string[] args)
{
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
var movies = new List <Movie>
{
new Movie {
Title = "The Dark Knight", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "The King's Speech", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "Casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "Star Wars V", Rating = 8.7f, Year = 1980
}
};
// var query = movies.Filter(m => m.Year > 2000)
// .OrderByDescending(m => m.Rating);
var query = from movie in movies
where movie.Year > 2000
orderby movie.Rating descending
select movie;
// var query = Enumerable.Empty<Movie>();
// try
// {
// query = movies.Filter(m => m.Year > 2000);
// }
// catch (Exception e)
// {
// Console.WriteLine(e.Message);
// }
// foreach (var movie in query)
// {
// Console.WriteLine(movie.Title);
// }
// Console.WriteLine(query.Count());
var enumerator = query.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
}
static void Main(string[] args)
{
//a deferred execution operator like "Where" is considered lazy, it won't execute until the foreach loop
//whereas "ToList()", "ToArray()", "Count()" are not, they will execute right away
//here we are calling our Random method, but it won't create an infinate loop because we are only "yielding" the first 10(.Take(10)) results
//this is because Take() is a streaming operator it only goes through the data until it gets the number of items it needs then stops
//if we did not have the Take() streaming operator below, the below query (while deferred) produces an infinate loop
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10);
//because Mylinq.Random() is a deferred execution method it doesn't get executed until the following foreach loop
foreach (var number in numbers)
{
Console.WriteLine(number);
}
//you can use streaming and non streaming in the same statement. this would be something like
// var query = movies.Where(m => m.Year > 2000)
// .OrderByDescending(m => m.Rating)
//above the streaming part of the the query is the Linq operator "Where" this is just getting movies > 2000 and creating that subset of data
//the non streaming part is "OrderByDescending" this has to look at the entire subset to order them
//it makes sense to do it this way so you are not ordering the entire data set then pulling out the data you need, you are only ordering the movies
//that were released after 2000, it is more efficient this way when in comes to in memory data(List, Array, IEnumerable)
var movies = new List <Movie>
{
new Movie {
Title = "The Dark Knight", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "Teh King's Speech", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "Casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "Star Wars V", Rating = 8.7f, Year = 1980
},
};
//here we are building the query
//if you want to not use deferred excution and build a concrete list, you need to add .ToList(), .ToArray(), .ToDictionary() at end of the query at this point we
//have a list of movies we can the do things on that list
var query = movies.Filter(m => m.Year > 2000);
//with deferred execution queries do not get executed until the foreach loop
//this is the same as PHP execute command I think
foreach (var movie in query)
{
Console.WriteLine(movie.Title);
}
}
static void Main(string[] args)
{
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
var movies = new List <Movie>
{
new Movie {
Title = "The Dark Knight", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "The Kings Speech", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "Casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "Star Wars V", Rating = 8.7f, Year = 1980
},
};
var query_1 = Enumerable.Empty <Movie>();
query_1 = movies.Where(m => m.Year > 2000)
/**
* OrderBy is a Non streaming operator where Order is a streaming operator
* So it is better to filter first then sort
*/
.OrderByDescending(m => m.Rating);
//Later
query_1 = query_1.Take(1);
foreach (var movie in query_1)
{
Console.WriteLine(movie.Title);
}
//Custom Filter
//var query_2 = movies.Filter(m => m.Year > 2000);
//Forces to execute immediately rather than deferred execution
//query_2.Count();
//var enumerator = query_2.GetEnumerator();
//while (enumerator.MoveNext())
//{
// Console.WriteLine(enumerator.Current.Title);
//}
}
static void Main(string[] args)
{
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
var movies = new List <Movie> {
new Movie {
Title = "The Dark Kniht", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "The King's Speech", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "Casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "Star Wars V", Rating = 8.7f, Year = 1980
}
};
var sw = new Stopwatch();
//var query = movies.Where(m => m.Year > 2000);.
//var query = movies.Filter(m => m.Year > 2000);
//var query = movies.Where(m => m.Year > 2000);
//var query = movies.Filter(m => m.Year > 2000);
//sw.Start();
//var query = movies.AsParallel().Where(m => m.Year > 2000);
//var query = movies.Where(m => m.Year > 2000);
//var query = movies.Filter2(m => m.Year > 2000);
var query = movies.Filter(m => m.Year > 2000);
//foreach (var movie in query) {
// Console.WriteLine(movie.Title);
//}
//sw.Stop();
//Console.WriteLine("Elapsed={0}", sw.Elapsed);
Console.WriteLine(query.Count());
var enumerator = query.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
Console.ReadLine();
}
static void Main(string[] args)
{
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10);
foreach (var number in numbers)
{
Console.WriteLine($"Skaiciu: {number}");
}
var movies = new List <Movie>()
{
new Movie()
{
Title = "Inception", Rating = 9.1f, Year = 2009
},
new Movie()
{
Title = "The King's Speach", Rating = 8.0f, Year = 2004
},
new Movie()
{
Title = "Ekskursante", Rating = 8.5f, Year = 2014
},
new Movie()
{
Title = "Casablanka", Rating = 8.5f, Year = 1942
},
};
var query = movies.Filter(m => m.Year > 2000)
.OrderByDescending(m => m.Rating);
var query2 = from movie in movies
where movie.Year > 2000
orderby movie.Rating descending
select movie;
var enumerator = query2.GetEnumerator();
//Console.WriteLine(query.Count());
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
//foreach (var movie in query)
//{
// Console.WriteLine(movie.Title);
//}
}
static void Main(string[] args)
{
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
var movies = new List <Movie>()
{
new Movie()
{
Title = "The Dark knight", Year = 2008, Rating = 8.9F
},
new Movie()
{
Title = "The king's speech", Year = 2010, Rating = 8.0F
},
new Movie()
{
Title = "Casablanca", Year = 1942, Rating = 8.5F
},
new Movie()
{
Title = "StarWar V", Year = 1980, Rating = 8.7F
}
};
var query = movies.Filter(x => x.Year > 2000)/*.ToList()
* .Take(1)Where(m => m.Year > 2000)*/
.OrderByDescending(m => m.Rating);
//It's more efficient to Always filter before sorting
//Where query Operator have differed excecution
//ToList and Count query Operators forces immediate excecution
var enumerator = query.GetEnumerator();
/*Console.WriteLine(query.Count());*/
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
/*foreach (var movie in query)
* {
* Console.WriteLine(movie.Title);
* }*/
}
static void Main(string[] args)
{
var numbers = MyLinq.Random()
.Where(n => n > 0.5)
.Take(10);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
var movies = new List <Movie>
{
new Movie {
Title = "The dark knight", Rating = 8.9f, Year = 2020
},
new Movie {
Title = "The purple knight", Rating = 7.9f, Year = 2019
},
new Movie {
Title = "The red knight", Rating = 3.9f, Year = 2020
},
new Movie {
Title = "The blue knight", Rating = 4.9f, Year = 2018
},
new Movie {
Title = "The brown knight", Rating = 2.9f, Year = 2019
},
new Movie {
Title = "The pink knight", Rating = 10.0f, Year = 2017
},
new Movie {
Title = "The yellow knight", Rating = 6.4f, Year = 2016
}
};
var query = movies.Where(w => w.Year > 2017)
.OrderByDescending(w => w.Rating);
var enumerator = query.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
}
static void Main(string[] args)
{
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10).OrderBy(n => n);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
var movies = new List <Movie>
{
new Movie {
Title = "The Dark Knight", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "The King's Speech", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "Casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "Star Wars V", Rating = 8.7f, Year = 1980
}
};
var DeferredExecutionTime = DateTime.Now;
var queryWithDeferredExecution = movies.Filter(x => x.Year > 2008);
var enumerator2 = queryWithDeferredExecution.GetEnumerator();
while (enumerator2.MoveNext())
{
Console.WriteLine(enumerator2.Current.Title);
}
Console.WriteLine("Time spend of Deferred Execution " + (DateTime.Now - DeferredExecutionTime).TotalMilliseconds);
var DeferredImmediatelyTime = DateTime.Now;
var queryWithImmediately = movies.Filter(x => x.Year > 2008).OrderByDescending(x => x.Rating).ToList();
var enumerator = queryWithImmediately.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
Console.WriteLine("Time spend of Immediately Execution " + (DateTime.Now - DeferredImmediatelyTime).TotalMilliseconds);
}
static void Main(string[] args)
{
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10); //exp of Deffered Streaming operators
foreach (var number in numbers)
{
WriteLine(number);
}
WriteLine();
var movies = new List <Movie>
{
new Movie {
Title = "The Dark Knight", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "The King's Speech", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "Casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "Star Wars V", Rating = 8.7f, Year = 1980
}
};
var query = movies.Where(m => m.Year > 2000) //"where" - Streaming Operator-looks at each item and if finds
//a match Returns/Yeilds that match to main code right away, then goes back to eterate futher
.OrderByDescending(m => m.Rating); // - NonStreaming Operator-iterate through ALL items and then goes back to the main code
//foreach (var movie in query)
//{
// WriteLine(movie.Title);
//}
//Console.WriteLine(query.Count());
var enumerator = query.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
ReadKey();
}
static void Main(string[] args)
{
var movies = new List <Movie>
{
new Movie {
Title = "The Dark Knight", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "The King's Speech", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "Casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "Star Wars V", Rating = 8.7f, Year = 1980
}
};
var query = movies.Where(m => m.Year > 2000)
.OrderByDescending(m => m.Rating);
foreach (var movie in query)
{
Console.WriteLine(movie.Title);
}
Console.WriteLine("*************");
var query2 = movies.Filter(m => m.Year > 2000);
var enumerator = query2.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
Console.WriteLine("*************");
var q3 = MyLinq.Random().Where(x => x > 0.5).Take(10);
foreach (var i in q3)
{
System.Console.WriteLine(i);
}
}
static void Main(string[] args)
{
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
var movies = new List <Movie>
{
new Movie {
Title = "The Dark Knight", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "The King' Speech", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "Casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "Star Wars V", Rating = 8.7f, Year = 1980
}
};
//var query = movies.Where(m => m.Year > 2000);
//var query = movies.Filter(m => m.Year > 2000);
var query = movies.Where(m => m.Year > 2000)
.OrderByDescending(m => m.Rating);
var enumerator = query.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
//foreach (var movie in query)
//{
// Console.WriteLine(movie.Title);
//}
}
static void Main(string[] args)
{
//var randomNum = new Random();
var getNum = MyLinq.Random().Where(n => n < .3).OrderBy(n => n).Take(10);
foreach (var item in getNum)
{
Console.WriteLine(item);
}
var movies = new List <Movies>()
{
new Movies {
Title = "Airbender", Rating = 1.9f, Year = 1999
},
new Movies {
Title = "Transformers", Rating = 4.8f, Year = 2007
},
new Movies {
Title = "Patton", Rating = 4.9f, Year = 1970
},
new Movies {
Title = "Trolls", Rating = 4.6f, Year = 2018
},
new Movies {
Title = "Batman", Rating = 3.8f, Year = 1998
}
};
var query = movies.Where(m => m.Year > 2000).OrderBy(m => m.Title);
var ennumerator = query.GetEnumerator();
while (ennumerator.MoveNext())
{
Console.WriteLine(ennumerator.Current.Title);
}
Console.WriteLine("-----------------");
foreach (var movie in query)
{
Console.WriteLine(movie.Title);
}
}
static void Main(string[] args)
{
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
var movies = new List <Movie>
{
new Movie {
Title = "The Dark Knight", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "The King's Speech", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "Casablanca", Rating = 88.5f, Year = 1942
},
new Movie {
Title = "Star Wars V", Rating = 8.7f, Year = 1980
},
};
//var query = movies.Where(m => m.Year > 2000)
// .OrderBy(m => m.Rating);
var query = from movie in movies
where movie.Year > 2000
orderby movie.Rating descending
select movie;
var enumartor = query.GetEnumerator();
while (enumartor.MoveNext())
{
Console.WriteLine(enumartor.Current.Title);
}
Console.ReadLine();
}
static void Main(string[] args)
{
var numbers = MyLinq.Random().Where(n => n > 0.4).Take(10);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
var movies = new List <Movie>
{
new Movie {
Title = "The Dark Knight", Rating = 8.9f, Year = 2012
},
new Movie {
Title = "The King's Speech", Rating = 8.5f, Year = 2007
},
new Movie {
Title = "Casablanca", Rating = 8.2f, Year = 1900
},
new Movie {
Title = "Start Wars V", Rating = 8.3f, Year = 2004
}
};
var query = movies.Filter(m => m.Year > 2000).ToList().Take(1);
Console.WriteLine(query.Count());
IEnumerator <Movie> enumerator = query.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
//foreach (var movie in query)
//{
// Console.WriteLine(movie.Title);
//}
Console.ReadKey();
}
static void Main(string[] args)
{
var movies = new List <Movie>()
{
new Movie()
{
Title = "The Dark Knight", Rating = 8.9f, Year = 2008
},
new Movie()
{
Title = "The King's Speech", Rating = 8.0f, Year = 2010
},
new Movie()
{
Title = "Casablanca", Rating = 8.5f, Year = 1942
},
new Movie()
{
Title = "Star Wars V", Rating = 8.7f, Year = 1980
}
};
var query = movies.Filter(m => m.Year > 2000);
var enumerator = query.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
//This uses a static method with an infinite loop, which uses deferred execution (facilitated by 'yield return'),
//to allow only 10 results to be returned, rather than looping forever. This is because the Random() method yields to
//caller - Take(10) - which completes once 10 values have been found.
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
}
private static void Main()
{
// streeming, non streeming
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
var movies = new List <Movies>
{
new Movies {
Rate = 8.9f, Title = "The Dark Night", Year = 2008
},
new Movies {
Rate = 9.8f, Title = "Cazablanca", Year = 1942
},
new Movies {
Rate = 8.9f, Title = "The King's Speach", Year = 2010
},
new Movies {
Rate = 9.8f, Title = "Star Ware V", Year = 1980
}
};
var query = movies.Filter(m => m.Year > 2000).ToList();
Console.WriteLine(query.Count);
foreach (var movie in query)
{
Console.WriteLine(movie.Title);
}
//var enumrator = query.GetEnumerator();
//while (enumrator.MoveNext())
//{
// Console.WriteLine(enumrator.Current.Title);
//}
}
static void Main(string[] args)
{
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10).ToList();
numbers.ForEach(n => Console.WriteLine(n));
var movies = new List <Movie>
{
new Movie {
Title = "The Dark Night", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "The King's Speech", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "Casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "Star Wars V", Rating = 8.7f, Year = 1980
}
};
var selectedMovies = movies.Where(m => m.Year > 1950)
.OrderByDescending(m => m.Rating)
.ToList();
// var selectedMovies = movies.Filter(m => m.Year > 2000).ToList();
// selectedMovies.ForEach(m => Console.WriteLine($"{m.Title,-20} {m.Rating,5} {m.Year,5}"));
//var enumerator = selectedMovies.GetEnumerator();
//while (enumerator.MoveNext())
//{
// Console.WriteLine(enumerator.Current.Title);
//}
Console.WriteLine("\n\nPress any key to exit...");
Console.ReadLine();
}
static void Main(string[] args)
{
var numbers = MyLinq.Random().Where(xp => xp > 0.5).Take(10);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
var movies = new List <Movie>
{
new Movie {
Title = "The Dark Knight", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "The King's Speech", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "Casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "Star Wars V", Rating = 8.7f, Year = 1980
}
//new Movie { Title = "", Rating = 8.f, Year = };
};
var query = movies.Where(xD => xD.Year > 2000).OrderByDescending(xD => xD.Rating);
//Console.WriteLine(query.Count());
var enumerator = query.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
}
static void Main(string[] args)
{
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
var movies = new List <Movie>
{
new Movie {
Title = "Spirited Away", Rating = 8.5f, Year = 2001
},
new Movie {
Title = "Your Name.", Rating = 8.5f, Year = 2016
},
new Movie {
Title = "Princess Mononoke", Rating = 8.4f, Year = 1997
},
new Movie {
Title = "A Silent Voice", Rating = 8.3f, Year = 2016
},
new Movie {
Title = "My Neighbor Totoro", Rating = 8.1f, Year = 1988
}
};
var query = movies.Where(m => m.Year > 2000).OrderByDescending(m => m.Rating);
var enumerator = query.GetEnumerator();
//while (enumerator.MoveNext())
//{
// Console.WriteLine(enumerator.Current.Title);
//}
}
static void Main(string[] args)
{
IEnumerable <double> numbers = MyLinq.Random().Where(n => n > 0.5).Take(10);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
List <Movie> movies = new List <Movie>
{
new Movie {
Title = "The Dark Knight", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "The Kings Speech", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "Casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "Star Wars V", Rating = 8.7f, Year = 1980
}
};
IEnumerable <Movie> query = from movie in movies
where movie.Year > 2000
orderby movie.Rating descending
select movie;
IEnumerator <Movie> enumerator = query.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
}
static void Main(string[] args)
{
var movies = new List <Movie>
{
new Movie {
Title = "The Dark Knight", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "The King's Speech", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "Casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "Star Wars V", Rating = 8.7f, Year = 1980
}
};
// Want movies after year 2000
// Method query
Console.WriteLine("-----Movies after 2000 - method query-----\n");
var query = movies.Where(m => m.Year > 2000);
foreach (var m in query)
{
Console.WriteLine(m.Title);
}
// Custom extension method - undeferred
Console.WriteLine("\n\n-----Movies after 2000 - custom method, undeferred-----\n");
var query2 = movies.Filter(m => m.Year > 2000);
Console.WriteLine(query2.Count());
foreach (var m in query2)
{
Console.WriteLine(m.Title);
}
// Custom extension method - deferred
Console.WriteLine("\n\n-----Movies after 2000 - custom method, deferred-----\n");
var query3 = movies.FilterDeferred(m => m.Year > 2000);
Console.WriteLine(query3.Count());
foreach (var m in query3)
{
Console.WriteLine(m.Title);
}
// Using enumerator
Console.WriteLine("\n\n-----Movies after 2000 - enumerator-----\n");
var enumerator = query2.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
// Undeferred execution with exception
Console.WriteLine("\n\n-----Movies after 2000 - custom method, undeferred, exception-----\n");
var query4 = Enumerable.Empty <Movie>();
try
{
query4 = movies.FilterDeferred(m => m.YearExc > 2000).ToList();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.WriteLine(query4.Count());
foreach (var m in query4)
{
Console.WriteLine(m.Title);
}
// Deferred execution with exception
Console.WriteLine("\n\n-----Movies after 2000 - custom method, deferred, exception-----\n");
var query5 = movies.FilterDeferred(m => m.YearExc > 2000);
try
{
Console.WriteLine(query4.Count());
foreach (var m in query4)
{
Console.WriteLine(m.Title);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
// Deferred execution with infinite source
Console.WriteLine("\n\n-----Infinite list of random numbers, deferred-----\n");
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10);
foreach (var num in numbers)
{
Console.WriteLine(num);
}
}
static void Main(string[] args)
{
#region Region7 - Streaming opeartors
Console.WriteLine("Streaming opeartors");
var numbers = MyLinq.Random().Where(n => n > 0.5).Take(10);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
Console.WriteLine("**********");
Console.WriteLine("\r");
#endregion
/*******************************************/
#region Region6 - Non-streaming operator (OrderBy)
/*
* Operator that offer deferred execution also can be devided into
* streaming operator(Where) and non-streaming operator(OrderBy)
*/
Console.WriteLine("Non-streaming operator (OrderBy)");
var movies6 = new List <Movie> {
new Movie {
Title = "the dark", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "the king", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "star wars", Rating = 8.7f, Year = 1980
}
};
var query6 = movies6.Where(m => m.Year > 2000)
.OrderByDescending(m => m.Rating);
var enumerator3 = query6.GetEnumerator();
while (enumerator3.MoveNext())
{
Console.WriteLine(enumerator3.Current.Title);
}
Console.WriteLine("**********");
Console.WriteLine("\r");
#endregion
/*******************************************/
#region Region5 - Streaming operator (Where)
/*
* Operator that offer deferred execution also can be devided into
* streaming operator(Where) and non-streaming operator(OrderBy)
*/
Console.WriteLine("Streaming operator (Where)");
var movies5 = new List <Movie> {
new Movie {
Title = "the dark", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "the king", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "star wars", Rating = 8.7f, Year = 1980
}
};
var query5 = movies5.Where(m => m.Year > 2000);
var enumerator2 = query5.GetEnumerator();
while (enumerator2.MoveNext())
{
Console.WriteLine(enumerator2.Current.Title);
}
Console.WriteLine("**********");
Console.WriteLine("\r");
#endregion
/*******************************************/
#region Region4 - Custom filter operator with deferred execution and GetEnumerator()"
Console.WriteLine("Custom filter operator with deferred execution and GetEnumerator()");
var movies4 = new List <Movie> {
new Movie {
Title = "the dark", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "the king", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "star wars", Rating = 8.7f, Year = 1980
}
};
var query4 = movies4.FilterWithDeferredExecution(m => m.Year > 2000);
var enumerator = query4.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
Console.WriteLine("**********");
Console.WriteLine("\r");
#endregion
/*******************************************/
#region Region3 - Custom filter operator with deferred execution given by "yield return"
Console.WriteLine("Custom filter operator with deferred execution given by yield return");
var movies3 = new List <Movie> {
new Movie {
Title = "the dark", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "the king", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "star wars", Rating = 8.7f, Year = 1980
}
};
var query3 = movies3.FilterWithDeferredExecution(m => m.Year > 2000);
foreach (var movie in query3)
{
Console.WriteLine(movie.Title);
}
Console.WriteLine("**********");
Console.WriteLine("\r");
#endregion
/*******************************************/
#region Region2 - Custom filter operator
Console.WriteLine("Custom filter operator");
var movies2 = new List <Movie> {
new Movie {
Title = "the dark", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "the king", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "star wars", Rating = 8.7f, Year = 1980
}
};
var query2 = movies2.Filter(m => m.Year > 2000);
foreach (var movie in query2)
{
Console.WriteLine(movie.Title);
}
Console.WriteLine("**********");
Console.WriteLine("\r");
#endregion
/*******************************************/
#region Region1 - Base code
Console.WriteLine("Base code");
var movies = new List <Movie> {
new Movie {
Title = "the dark", Rating = 8.9f, Year = 2008
},
new Movie {
Title = "the king", Rating = 8.0f, Year = 2010
},
new Movie {
Title = "casablanca", Rating = 8.5f, Year = 1942
},
new Movie {
Title = "star wars", Rating = 8.7f, Year = 1980
}
};
var query = movies.Where(m => m.Year > 2000);
foreach (var movie in query)
{
Console.WriteLine(movie.Title);
}
Console.WriteLine("**********");
Console.WriteLine("\r");
#endregion
/*******************************************/
// Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
static void Main(string[] args)
{
var movies = new List <Movie>
{
new Movie {
Title = "Forest Gump", Rating = 8.5f, Year = 1994
},
new Movie {
Title = "Avatar", Rating = 7.4f, Year = 2009
},
new Movie {
Title = "Saving Private Ryan", Rating = 8.1f, Year = 1998
},
new Movie {
Title = "Cast Away", Rating = 7.5f, Year = 2000
}
};
Console.WriteLine("****Custom Filter [defered execution] operator writed in extension method syntax****");
// Custom Filter operator which uses deferred execution with yield return
// that runs the same as Linq query
// Query does no real work until we force the query to produce a result
var query = movies.Filter(x => x.Year > 1999);
var enumerator = query.GetEnumerator();
// Produce result that force execution
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
Console.WriteLine("****Count [immediate execution] operator writed in extension method syntax****");
// Count operator which uses immediate execution with yield return
Console.WriteLine(query.Count());
Console.WriteLine("****Where [deferred streaming execution] operator writed in extension method syntax****");
// Count operator which uses deferred streaming execution with yield return
query = movies.Where(x => x.Year > 1999);
enumerator = query.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
Console.WriteLine("****Where [deferred streaming execution] and then ToList [immediate execution] operators writed in extension method syntax****");
// Where operator which uses deferred streaming execution with yield return command
// but ended with ToList which uses immediate execution with simple return command
query = movies.Where(x => x.Year > 1999).ToList();
enumerator = query.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
Console.WriteLine("****Where [deferred streaming execution] and then OrderByDescending [deferred non-streaming execution] operators writed in extension method syntax****");
// Where operator which uses deferred streaming execution with yield return command
// but ended with OrderByDescending which uses deferred non-streaming execution with yield return command
query = movies.Where(x => x.Year > 1999).OrderByDescending(m => m.Rating);
enumerator = query.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
Console.WriteLine("****Where [deferred streaming execution] and then order by descending [deferred non-streaming execution] operators writed in query syntax****");
// Where operator which uses deferred streaming execution with yield return command
// but ended with order by descending which uses deferred non-streaming execution with yield return command
query = from movie in movies
where movie.Year > 1999
orderby movie.Rating descending
select movie;
enumerator = query.GetEnumerator();
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current.Title);
}
Console.WriteLine("****Call InfiniteRandom() method which is infinite loop that stopped after taking 10 elements****");
var numbers = MyLinq.InfiniteRandom().Where(x => x > 50).Take(10);
foreach (var number in numbers)
{
Console.WriteLine(number);
}
// Sum Up
// 1 [immediate execution] means that the data source is read and the operation
// is performed at the point in the code where the query is declared.
// 2 [deferred execution] means that the operation is not performed at the point in the code
// where the query is declared. The operation is performed only when the query variable is enumerated
// 3 [streaming operators] do not have to read all the source data before they can yield a result element.
// 4 [non-streaming operators] must read all the source data before they can yield a result element.
}
