C#

Tom Wright wrote:

I need to do a BeginSend to make my client socket app truly async?

Quoted from MSDN:

If you need to determine the current state of the connection, make a nonblocking, zero-byte Send call. If the call returns successfully or throws a WAEWOULDBLOCK error code (10035), then the socket is still connected; otherwise, the socket is no longer connected.

public class Foo{
    public delegate void dSendParameters(string para);

    public event SendParameters;

    protected virtual OnSendParameters(parm list){
        if(SendParameters != null){
            SendParameters(someString);
        }
    }

    private void buttonClickMe_Click(object sender, EventArgs e){
        OnSendParameters(someparams);
    }

}

<br />
public delegate void dSendParameters(string para);    <br />
public event EventHandler SendParameters;<br />
public OtherClass(Delegate dSend)<br />
{<br />
 //HOW TO MAKE THE DELEGATE available<br />
<br />
}<br />

public class SomeOtherCode{


    public void SampleMethod(){
        Foo foo = new Foo();
        foo.SendParameters += new dSendParameters(SomeMethod);
    }


    public void SomeMethod(string param){
      ...
    }
}

public delegate double DFunction(double d);

public double Sin(double d){
    return Math.Sin(d);
}

public double PerformAction(DFunction d){
    double e = d(5d);
    return e;
}

private void button1_Click(object sender, EventArgs e) {
    PerformAction(new DFunction(Sin));
}

public class OtherClass {
   private dSendParameters _dSend;

   public OtherClass(dSendParameters dSend) {
      _dSend = dSend;
   }

   public void SomeOtherMethodCallingDSend() {
      _dSend("SomeParam");
   }
}

public class OtherClass <br />
{<br />
   Delegate _dSend;<br />
   public OtherClass(Delegate dSend)<br />
 {<br />
      _dSend = dSend;   <br />
}

public abstract class MyClass<T>
{
    private static readonly MyClass<T> _instance = CreateInstance();
    
    public static MyClass<T> Instance
    {
        get { return _instance; }
    }
    
    private static MyClass<T> CreateInstance()
    {
        Type itemType = typeof(T);
        Type resultType = null;
        
        if (typeof(InterfaceA).IsAssignableFrom(itemType))
        {
            resultType = typeof(<span>MyClassA<></span>).MakeGenericType(itemType);
        }
        else if (typeof(InterfaceB).IsAssignableFrom(itemType))
        {
            resultType = typeof(<span>MyClassB<></span>).MakeGenericType(itemType);
        }
        
        if (null == resultType) throw new ArgumentException("Type parameter \"T\" must implement InterfaceA or InterfaceB.");
        return (<span>MyClass<T></span>)Activator.CreateInstance(resultType);
    }
}
 
internal sealed class MyClassA<T> : MyClass<T> where T : InterfaceA
{
    ...
}
 
internal sealed class MyClassB<T> : MyClass<T> where T : InterfaceB
{
    ...
}

interface IAmDaddy
{
}

interface interfaceA : IAmDaddy
{
}

interface interfaceB : IAmDaddy
{
}

public List<T> where T : IAmDaddy

Tech, life, family, faith: Give me a visit.
I'm currently blogging about: Dumbest. Movie. Title. Evaaar.
The apostle Paul, modernly speaking: Epistles of Paul

Judah Himango

<br />
"(\\w+)\\s*=\\s*"<br />
"\"\\s*(.*?)\\s*\""