/*
* public void Process(string path)
* {
* var photo = Photo.Load(path);
* var filters = new PhotoFilters();
* filters.ApplyBrightness(photo);
* filters.ApplyContrast(photo);
* filters.Resize(photo);
*
* photo.Save();
* }
*/
// initially we can use the above commented method. But when we use delegate we can do :
public void Process(string path, PhotoFilterHandler filterHandler)
{
var photo = Photo.Load(path);
filterHandler(photo);
photo.Save();
}
public void Process(string photoPath, PhotoFilterHandler filterHandler)
{
var photo = new Photo(photoPath);
filterHandler(photo); //this executes the group of functions pointed to by the delegat
//so long as they have the signature defined above
}
public void Process(string path, PhotoFilterHandler photoFilterHandler)
{/* Pass a delegate */
var photo = Photo.Load(path);
/* Using delegates. Instead of having these hardcoded */
photoFilterHandler(photo); // This delegate points to the methods.
photo.Save();
}
public void Process(PhotoFilterHandler filterHandler)
{
var photo = new Photo();
filterHandler(photo);
photo.Save();
}
public void Process(string path, PhotoFilterHandler filterHandler)
{
var photo = new Photo();
photo.Name = "Photo Alex";
filterHandler(photo);
}
//Now this method doesn't know what filters will be applied, it's the responsibility of client to decide what filters to apply
//So this framework doesn't have to be recompiled and redeployed for applying new filter/any number of filters which makes it extensible
public void Process(string path, PhotoFilterHandler filterHandler)
{
var photo = Photo.Load(path);
// Calling the method here through this delegate instance, the caller will pass pointers to method, and we're calling it here like method(args)
filterHandler(photo);
photo.Save();
}
public static void Demo()
{
var processor = new PhotoProcessor();
var filters = new PhotoFilters();
PhotoFilterHandler handler = filters.ApplyContrast;
handler += filters.AdjustBrightness;
handler += SomeOtherFilter;
processor.Process("123.jpg", handler);
}
public void Process(string path, PhotoFilterHandler filterHandler)
{
var photo = Photo.Load(path);
// By calling the filterHandler this method doesn't know which photo process will be applied
// It's up to the client to define this
filterHandler(photo);
photo.Save();
}
public void Process(string path, PhotoFilterHandler filterHandler)
{
var photo = Photo.Load(path);
var filters = new PhotoFilters();
//filters.ApplyBrightness(photo);
//filters.ApplyContrast(photo);
//filters.Resize(photo);
filterHandler(photo);
}
public delegate void PhotoFilterHandler(Photo photo); //A delegate is a class derived from System.MulticastDelegate
public void Process(string path, PhotoFilterHandler filterHandler)
{
//System.Action<> //Action points to a method that returns void
//System.Func<>//Func points to a method that returns a value (out TResult)
var photo = Photo.Load(path);
filterHandler(photo);
photo.Save();
}
public string Process(string path, PhotoFilterHandler filterHander, string TBH)
{
var photo = Photo.Load(path);
photo.PhotoMessage += "Photo Class Hit \n";
photo.PhotoMessage += "Photo Class Contains a Delegate Call PhotoFilterHandler \n";
photo.PhotoMessage += "Processing Filters Using Delegate Now \n";
filterHander(photo);
TBH += photo.PhotoMessage;
return(TBH);
}
public delegate void PhotoFilterHandler(Photo photo); // refer to all methods that return void and have a parameter type of photo
public void Process(string path, PhotoFilterHandler filterHandler)
{
var photo = Photo.Load(path);
//var filter = new PhotoFilters();
//filter.ApplyBrightness(photo);
//filter.ApplyContrast(photo);
//filter.Resize(photo);
filterHandler(photo);
photo.Save();
}
public delegate void PhotoFilterHandler(Photo photo); // delegate method
public void Process(string path, PhotoFilterHandler photofilterHandler0)
{
Photo photo = Photo.Load(path); // invoke the Photo.Load method passed in path
photofilterHandler0(photo);
//PhotoFilters photoFilters = new PhotoFilters();
//photoFilters.ApplyBrightness(photo);
//photoFilters.ApplyContrast(photo);
//photoFilters.Resize(photo);
photo.Save();
}
//Pass in delegate to this function using custom delegates
public void Process(string path, PhotoFilterHandler filterHandler)
{
Photo photo = new Photo();
photo = Photo.Load(path);
//This code means that this does not know what filters will be applied.
//Filters will be applied by client who is using this framework or
//application. May be they only want to call one method. Also with delegate
//clients will not have to recompile the code. They can create and add and call
//methods they want.
//In this example, review Program.cs for code example on client(Consumer or developer of the frameowkr)
//that will use this delegate to call methods.
filterHandler(photo);
}
public delegate void PhotoFilterHandler(Photo photo); //need define signature of method you're responsible for calling
//we could use a generic delegate
//no need to delcare
//I put an example called SuperProcess
public void Process(string path, PhotoFilterHandler filterHandler)
{
//built in delegates
//System.Action - points to void method
//System.Func<> - returns a value
var photo = Photo.Load(path);
filterHandler(photo);
photo.Save();
}
// 2, Give an delegate as argument to the method
public void Process(string path, PhotoFilterHandler filterHandler)
{
var photo = Photo.Load(path);
// 3 - Pass the photo to the filter
// it means that this code doesn't know any longer what filter will be applied
// it is now the responsability of the client of this code
filterHandler(photo);
/* ------------- code before delegate ----------*/
//var filters = new PhotoFilters();
//filters.ApplyBrightness(photo);
//filters.ApplyContrast(photo);
//filters.Resize(photo);
photo.Save();
}
public void Process(string path, PhotoFilterHandler filehandler)
{
Console.WriteLine("Processing");
filehandler(new Photo());
}
public void Process(Photo photo, PhotoFilterHandler filterHandler)
{
filterHandler(photo);
}
public void Process(string path,PhotoFilterHandler photoFilterHandler)
{
var photo = new Photo();
photoFilterHandler(photo);
}
