C#

using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
{
  PictrureBox1.Image=Image.FromStream(fs);
}
pictuer1.Image.Save(New Dir);
File.Delete(Dir);

manormi1 wrote:

Do i need some sort of function around this that I can call recursively with different URL's ?

Illegal Operation wrote:

My question is this, How can I make this code generic so that all my forms can inherit this functionality?

public static class FormsRepository
{
    static Dictionary<Type, Form> cache = new Dictionary<Type, Form>();

    public static T GetFormInstance<T>() where T : Form, new()
    {
        Type type = typeof(T);
        T form = null;
        if (cache.ContainsKey(type))
        {
            if (cache[type] == null || cache[type].IsDisposed)
                cache[type] = new T();
            form = (T)cache[type];
        }
        else
        {
            form = new T();
            cache.Add(type, form);
        }
        return form;
    }
}

Form2 frm = FormsRepository.GetFormInstance<Form2>();
frm.Show();

Illegal Operation wrote:

makes sure that there will always only be one instance of a form open in my MDI app.

WhiteWolf19 wrote:

just like the page below

<code>
public class Customer
{
    public string Name{get; set;}
    ...
}

public class CustomerCollection : CollectionBase
{
    public Customer this[int index]{
        get{ return innerList[index];}
        set{ innerList[index] = value;}
    }

    public void Add(Customer item){
       innerList.Add(item);
    }
}

</code>

Dictionary<string, Customer> dic;
ICollection<Customer> Customers {
  get { return this.dic.Values; }
}

CodingYoshi wrote:

What should I do if I want the client to be able to do this:

foreach (Customer c in this._customers)
{
c.Name = "whatever";
}

public class CustomerCollection : IEnumerable<Customer>
{
    public IEnumerator<Customer> GetEnumerator()
    {
        foreach(KeyValuePair<string,Customer> item in _districts)
            yield return item.Value;
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public class Test
{
    private BackgroundWorker backgroundWorker;

    public Test()
    {
        backgroundWorker = new BackgroundWorker();
        backgroundWorker.WorkerReportsProgress = true;
        backgroundWorker.WorkerSupportsCancellation = true;
        backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);
        backgroundWorker.DoWork += new DoWorkEventHandler(backgroundWorker_DoWork);
        backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker_RunWorkerCompleted);
    }

    public void StartTest()
    {
        backgroundWorker.RunWorkerAsync();
    }

    private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
    {
        Console.WriteLine(e.ProgressPercentage);
    }

    private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
    {
        for (int i = 0; i <= 100; i++)
            backgroundWorker.ReportProgress(i);
    }

    private void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        Console.WriteLine("Done");
    }
}

Test t = new Test();
t.StartTest();