I want to use the status method but i dont understand how it works. Could someone show me an example of use please?
EventHandler < SvnStatusEventArgs > statusHandler = new EventHandler<SvnStatusEventArgs>(void(object, SvnStatusEventArgs) target);
client.Status(path, statusHandler);
Well, it'll work exactly like the svn status command : http://svnbook.red-bean.com/en/1.0/re26.html
You'll get the list of files pumped to the EventHandler:
using(SvnClient client = /* set up a client */ ){
EventHandler<SvnStatusEventArgs> statusHandler = new EventHandler<SvnStatusEventArgs>(HandleStatusEvent);
client.Status(#"c:\foo\some-working-copy", statusHandler);
}
...
void HandleStatusEvent (object sender, SvnStatusEventArgs args)
{
switch(args.LocalContentStatus){
case SvnStatus.Added: // Handle appropriately
break;
}
// review other properties of 'args'
}
Or if you don't mind inline delegates:
using(SvnClient client = new SvnClient())
{
client.Status(path,
delegate(object sender, SvnStatusEventArgs e)
{
if (e.LocalContentStatus == SvnStatus.Added)
Console.WriteLine("Added {0}", e.FullPath);
});
}
Note that the delegate versions of the SharpSvn functions are always a (tiny) bit faster than the revisions returns a collection as this method allows marshalling the least amount of information to the Managed world. You can use Svn*EventArgs.Detach() to marshall everything anyway. (This is what the .GetXXX() functions do internally)
The inline delegate version worked for me but the EventHandler<T> version didn't work until I set the type to EventHandler<SvnStatusEventArgs>.
Related
When using Apache Thrift [https://github.com/apache/thrift] to create a non blocking server in C#, the following Classes/Types cannot be recognized:
TNonblockingServerTransport
TNonblockingServer
I want to send command from my win10 laptop to control a time-consuming calculation performed on a high performance server (ubuntu). That's why I came to Apache Thrift. I have found the official C# version tutorial [https://github.com/apache/thrift/tree/master/tutorial/csharp] and it works well. This tutorial uses the so-called Blocking Mode (TSimpleServer). But in my situation, the time-consuming calculation procedure should be interrupt-able. Consequently, I must use a non-blocking server.
The logic is simple. For the server, I used a private flag forceStop. If the Client call Stop(), forceStop will set to true and the calculation loop will break.
// #Server#
// Server Set-Up
private void SetUp()
{
try
{
CalculatorHandler handler = new CalculatorHandler();
Calculator.Processor processor = new
Calculator.Processor(handler);
var serverTransport = new TServerSocket(9090);
TServer server = new TSimpleServer(processor, serverTransport);
// Use this for a multithreaded server
// server = new TThreadPoolServer(processor, serverTransport);
Console.WriteLine("Starting the server...");
server.Serve();
}
catch (Exception x)
{
Console.WriteLine(x.StackTrace);
}
}
private bool forceStop;
public int TimeConsumingOperation(int n1, int n2)
{
Console.WriteLine("add({0},{1})", n1, n2);
for (int i = 0; i < 10; i++)
{
//calculating
Thread.Sleep(500);
if (forceStop)
{
Quit();
}
}
return n1 + n2;
}
public void Stop()
{
forceStop = true;
}
// Client
// Button#1 Click callback
private void Button_Start_Click()
{
client.TimeConsumingOperation(0,0);
}
// Button#2 Click callback
private void Button_Stop_Click()
{
client.Stop();
}
//
I've found some useful examples in java [https://chamibuddhika.wordpress.com/2011/10/02/apache-thrift-quickstart-tutorial/]. I've try my best to convert the java code of non-block server to the corresponding C# code but I found that there seems to be no TNonblockingServerTransport in C#. Anyone could help me with this probelm?
// Java Code
public class NonblockingServer {
private void start() {
try {
TNonblockingServerTransport serverTransport = new TNonblockingServerSocket(7911);
ArithmeticService.Processor processor = new ArithmeticService.Processor(new ArithmeticServiceImpl());
TServer server = new TNonblockingServer(new TNonblockingServer.Args(serverTransport).
processor(processor));
System.out.println("Starting server on port 7911 ...");
server.serve();
} catch (TTransportException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
NonblockingServer srv = new NonblockingServer();
srv.start();
}
}
There's actually two answers to that question.
Possible implementation
Your setup is flawed, to begin with.
// #Server#
// Server Set-Up
private bool forceStop;
public void Stop()
{
forceStop = true;
}
Let's assume, we have two clients, both starting a new calculation. Now one client wants to abort. What happens?
The solution would be to structure it in a way where the calculation is a separate business logic object that is instantiated at TimeConsumingOperation() and made available to the client by some means, typically by returning some sort of ID.
When the client now wants to abort, it calls Stop(calcualtionID). The server side logic now routes that call to the implementation and triggers whatever the abort mechanism might be, with C# is is probably a CancellationToken.
A third call would be needed to query the final results from the server end once the calculation has finished. Note that we still work with a TSimpleServer and the reason it works is because we avoid blocking calls by means of the API design.
Nonblocking server
Yes, there is no implementation yet for C#. Since Thrift is Open Source, that probably simply means that there were nobody running into that use case so far and wanted to spend time on an implementation. That is not to say that such a use case may not exist.
What exists are
Threaded and Threadpool servers
Task.Run(() => { your code })
which may help to solve your use case. Also, when used with ASP.NET there is no need for a nonblocking server since the runtime offers enough support already for multiple connections.
Bottom line
There are certain ways to work around that limitation you experierenced. One additional alternative could be to become a contributor by porting one of the existing (e.g. Java) nonblocking implementation to NetStd (preferred, since C# and NetCore will mature into "deprecated" state with the next release and both be replaced by NetStd eventually)
In order to Synchronize events in an Outlook calendar Microsoft has provided the following documentation: https://msdn.microsoft.com/en-us/office/office365/howto/sync-calendar-view
To do that with C# .NET, they have provided the following Nuget package https://www.nuget.org/packages/Microsoft.Office365.OutlookServices-V2.0/
To play with that dll they have provided this basic sample: https://dev.outlook.com/restapi/tutorial/dotnet
Following that sample I have written the following code to get events:
OutlookServicesClient client =
new OutlookServicesClient(new Uri("https://outlook.office.com/api/v2.0"),
() => GetAccessToken(account));
ExceptionDispatchInfo unauthorizedException = null;
try
{
client.Context.SendingRequest2 += new EventHandler<SendingRequest2EventArgs>(
(sender, e) => InsertXCustomHeaders(sender, e, account));
client.Context.SendingRequest2 += new EventHandler<SendingRequest2EventArgs>(
(sender, e) => InsertSyncCustomHeaders(sender, e));
DateTime startDate = //Today
DateTime endDate = // 2 years from now;
IPagedCollection<IEvent> events = await client.Me.Calendars[calendarID].GetCalendarView(startDate, endDate).ExecuteAsync();
return events;
}
catch (WebException exception)
{
}
Source code of InsertXCustomHeaders and InsertSyncCustomHeaders used above:
private static void InsertXCustomHeaders(object sender, SendingRequest2EventArgs e, UserConnectedAccount connectedAccount)
{
e.RequestMessage.SetHeader("Authorization", string.Format("Bearer {0}", connectedAccount.AccessToken));
e.RequestMessage.SetHeader("UserAgent", GetUserAgent());
e.RequestMessage.SetHeader("client-request-id", "Bearer " + GetClientRequestID());
e.RequestMessage.SetHeader("return-client-request-id", "true");
}
private static void InsertSyncCustomHeaders(object sender, SendingRequest2EventArgs e)
{
int initialSyncMaxPageSize = DynamicPropertyRepository.GetSystemPropertyInt("InitialSyncMaxPageSize", 100);
e.RequestMessage.SetHeader("Prefer", "odata.track-changes");
e.RequestMessage.SetHeader("Prefer", string.Format("odata.maxpagesize = {0}", initialSyncMaxPageSize));
}
I have no issue getting events with that code, i.e. I am getting events in
IPagedCollection events variable above.
Issue I am facing:
I am unable to find how to get deltaToken, slipToken nextLink values as mentioned in the response at this link https://msdn.microsoft.com/en-us/office/office365/howto/sync-calendar-view with the above c# code.
Is Syncing of events even supported with C# .NET Nuget package: https://www.nuget.org/packages/Microsoft.Office365.OutlookServices-V2.0/?
Is there any sample to perform https://msdn.microsoft.com/en-us/office/office365/howto/sync-calendar-view with https://www.nuget.org/packages/Microsoft.Office365.OutlookServices-V2.0/ library?
First thing about that library: it isn't going to be maintained going forward, so keep in mind that new features and such won't get added to it. That's what you're seeing here, the library wasn't updated after sync support was added to the REST API.
Because of this, while you can force the headers into the request to enable sync behavior, the IPagedCollection doesn't expose anything that will help you do subsequent sync events, like deltaToken. For sync, you are going to want to move to something else. I've got a sample that doesn't use any library. Instead it's all custom code, so you have complete control over requests and responses.
Please consider the following simple code and then I will ask my question.
public static void Save(XmlDocument saveBundle)
{
ThreadStart threadStart = delegate
{
SaveToDatabase(saveBundle);
};
new Thread(threadStart).Start();
}
The issue with using threads in Visual Studio (2005) is you can't walk through them easily (I believe there is a way to switch threads which I have not looked into as I'm hoping there is an easier way).
So, in live, my code is more complex that then example above and we use a new thread as it's time critical but the principal is the same. Most importantly, it is not time critical in test!
At the moment, I will probably do something like using the #if debug but it just feels wrong to do so - Am I using the #if in the correct way here or is there a better way to resolve this?
public static void Save(XmlDocument saveBundle)
{
#if debug
{
SaveToDatabase(parameters);
}
#else
{
ThreadStart threadStart = delegate
{
SaveToDatabase(parameters);
};
new Thread(threadStart).Start();
}
#endif
}
}
Although I'm stuck on .NET 2.0 I am interested in any version from .NET 20. onwards (I'm sure one day I'll leave the Jurassic period and join everyone else)
I would say that your original code is lacking an important feature; some sort of mechanism of reporting back when the operation has completed (or failed):
public static void Save(XmlDocument saveBundle, Action<Exception> completedCallback)
{
ThreadStart threadStart = delegate
{
try
{
SaveToDatabase(saveBundle);
completedCallback(null);
}
catch (Exception ex)
{
completedCallback(ex);
}
};
new Thread(threadStart).Start();
}
That way, you can use some sort of synchronization method to orchestrate your unit-test:
Exception actualException = null;
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
instance.Save(xmlDocument, ex =>
{
actualException = ex;
waitHandle.Set();
});
waitHandle.WaitOne();
}
Assert.IsNull(actualException);
If what you truly want to do is not use the threading in your debug build - this is the correct way to do it and probably the quickest and most capable way of doing it as well. It may look a bit ugly but the alternative are just more bools, configurations and other work arounds.
If you're interested in debugging the thread directly (this is important perhaps if concurrency is an issue! You should always test as close to the production environment as possible) then you can simply go (Debug -> Windows -> Threads) and then right click the thread you would like to debug and "Switch to Thread".
Maybe You could put this threading code into a separate method and substitute that method when testing.
virtual void SaveToDBInSeparateThread(...)
{
ThreadStart threadStart = delegate
{
...
};
new Thread(threadStart).Start();
}
You could then instead of returning void return the thread run or something similar.
Or You can add an input parameter to Your method like below:
virtual void SaveToDB(bool inSeparateThread)
{
if(inSeparateThread)
{
ThreadStart threadStart = delegate
{
...
};
new Thread(threadStart).Start();
}
...
}
Or You can provide some kind of DatabaseSavingContext:
interface IDBSaveContext
{
public void SaveToDB(...)
}
And use different implementation (threaded, non-threaded) of this interface depending on execution type.
In a c# program for simulating a lan messenger, i have a callback function for beginreceive where i need to display the text received in a particular textbox..
this.textBox1.Text = sb.ToString();
However on doing so, I am getting a cross-thread operation not valid error.
I do realize that i need to use the object.invoke method but could u please provide me with the complete code to invoke a delegate because am still naive when it comes to threading.Thank you
You need to push the work back onto the UI; luckily, it is easy:
this.Invoke((MethodInvoker) delegate {
this.textBox1.Text = sb.ToString();
});
This uses the "anonymous method" and "captured variables" features of C# to do all the heavy lifting. In .NET 3.5, you may prefer to use Action, but that makes no real difference:
this.Invoke((Action) delegate {
this.textBox1.Text = sb.ToString();
});
You can use it in this way:
void MyCallback(IAsyncResult result)
{
if (textBox1.InvokeRequired) {
textBox1.Invoke(new Action<IAsyncResult>(MyCallBack),new object[]{result});
return;
}
// your logic here
}
This question already has answers here:
Where do I use delegates? [closed]
(8 answers)
Closed 9 years ago.
I think I understand the concept of a delegate in C# as a pointer to a method, but I cant find any good examples of where it would be a good idea to use them. What are some examples that are either significantly more elegant/better with delegates or cant be solved using other methods?
The .NET 1.0 delegates:
this.myButton.Click += new EventHandler(this.MyMethod);
The .NET 2.0 delegates:
this.myOtherButton.Click += delegate {
var res = PerformSomeAction();
if(res > 5)
PerformSomeOtherAction();
};
They seem pretty useful. How about:
new Thread(new ThreadStart(delegate {
// do some worker-thread processing
})).Start();
What exactly do you mean by delegates? Here are two ways in which they can be used:
void Foo(Func<int, string> f) {
//do stuff
string s = f(42);
// do more stuff
}
and
void Bar() {
Func<int, string> f = delegate(i) { return i.ToString(); }
//do stuff
string s = f(42);
// do more stuff
}
The point in the second one is that you can declare new functions on the fly, as delegates. This can be largely replaced by lambda expressions,and is useful any time you have a small piece of logic you want to 1) pass to another function, or 2) just execute repeatedly. LINQ is a good example. Every LINQ function takes a lambda expression as its argument, specifying the behavior. For example, if you have a List<int> l then l.Select(x=>(x.ToString()) will call ToString() on every element in the list. And the lambda expression I wrote is implemented as a delegate.
The first case shows how Select might be implemented. You take a delegate as your argument, and then you call it when needed. This allows the caller to customize the behavior of the function. Taking Select() as an example again, the function itself guarantees that the delegate you pass to it will be called on every element in the list, and the output of each will be returned. What that delegate actually does is up to you. That makes it an amazingly flexible and general function.
Of course, they're also used for subscribing to events. In a nutshell, delegates allow you to reference functions, using them as argument in function calls, assigning them to variables and whatever else you like to do.
I primarily use the for easy asynch programming. Kicking off a method using a delegates Begin... method is really easy if you want to fire and forget.
A delegate can also be used like an interface when interfaces are not available. E.g. calling methods from COM classes, external .Net classes etc.
Events are the most obvious example. Compare how the observer pattern is implemented in Java (interfaces) and C# (delegates).
Also, a whole lot of the new C# 3 features (for example lambda expressions) are based on delegates and simplify their usage even further.
For example in multithread apps. If you want several threads to use some control, You shoul use delegates. Sorry, the code is in VisualBasic.
First you declare a delegate
Private Delegate Sub ButtonInvoke(ByVal enabled As Boolean)
Write a function to enable/disable button from several threads
Private Sub enable_button(ByVal enabled As Boolean)
If Me.ButtonConnect.InvokeRequired Then
Dim del As New ButtonInvoke(AddressOf enable_button)
Me.ButtonConnect.Invoke(del, New Object() {enabled})
Else
ButtonConnect.Enabled = enabled
End If
End Sub
I use them all the time with LINQ, especially with lambda expressions, to provide a function to evaluate a condition or return a selection. Also use them to provide a function that will compare two items for sorting. This latter is important for generic collections where the default sorting may or may not be appropriate.
var query = collection.Where( c => c.Kind == ChosenKind )
.Select( c => new { Name = c.Name, Value = c.Value } )
.OrderBy( (a,b) => a.Name.CompareTo( b.Name ) );
One of the benefits of Delegates is in asynchronous execution.
when you call a method asynchronously you do not know when it will finish executing, so you need to pass a delegate to that method that point to another method that will be called when the first method has completed execution. In the second method you can write some code that inform you the execution has completed.
Technically delegate is a reference type used to encapsulate a method with a specific signature and return type
Some other comments touched on the async world... but I'll comment anyway since my favorite 'flavor' of doing such has been mentioned:
ThreadPool.QueueUserWorkItem(delegate
{
// This code will run on it's own thread!
});
Also, a huge reason for delegates is for "CallBacks". Let's say I make a bit of functionality (asynchronously), and you want me to call some method (let's say "AlertWhenDone")... you could pass in a "delegate" to your method as follows:
TimmysSpecialClass.DoSomethingCool(this.AlertWhenDone);
Outside of their role in events, which your probably familiar with if you've used winforms or asp.net, delegates are useful for making classes more flexible (e.g. the way they're used in LINQ).
Flexibility for "Finding" things is pretty common. You have a collection of things, and you want to provide a way to find things. Rather than guessing each way that someone might want to find things, you can now allow the caller to provide the algorithm so that they can search your collection however they see fit.
Here's a trivial code sample:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Delegates
{
class Program
{
static void Main(string[] args)
{
Collection coll = new Collection(5);
coll[0] = "This";
coll[1] = "is";
coll[2] = "a";
coll[3] = "test";
var result = coll.Find(x => x == "is");
Console.WriteLine(result);
result = coll.Find(x => x.StartsWith("te"));
Console.WriteLine(result);
}
}
public class Collection
{
string[] _Items;
public delegate bool FindDelegate(string FindParam);
public Collection(int Size)
{
_Items = new string[Size];
}
public string this[int i]
{
get { return _Items[i]; }
set { _Items[i] = value; }
}
public string Find(FindDelegate findDelegate)
{
foreach (string s in _Items)
{
if (findDelegate(s))
return s;
}
return null;
}
}
}
Output
is
test
there isn't really anything delgates will solve that can't be solved with other methods, but they provide a more elegant solution.
With delegates, any function can be used as long as it has the required parameters.
The alternative is often to use a kind of custom built event system in the program, creating extra work and more areas for bugs to creep in
Is there an advantage to use a delegate when dealing with external calls to a database?
For example can code A :
static void Main(string[] args) {
DatabaseCode("test");
}
public void DatabaseCode(string arg) {
.... code here ...
}
Be improved in code B :
static void Main(string[] args) {
DatabaseCodeDelegate slave = DatabaseCode;
slave ("test");
}
public void DatabaseCode(string arg) {
.... code here ...
}
public delegate void DatabaseCodeDelegate(string arg);
It seems that this is subjective, but an area where there are strong conflicting view points?