动态处理对象 [英] Disposing objects dynamically

问题描述

我有一个Disposeable类，它将对象传递给另一个继承IDisposable的类DisposeObject。



但是，我无法处理对象。我在这里想念任何事。



这是我的代码

I have a class "Disposeable" which passes the object to another class "DisposeObject" which inherits "IDisposable".

But, i couldn't able to dispose the object. Do i miss anythings here.

here is my code

public class Disposeable
    {
        List<object> objDisposableObject;

        public Disposeable(List<object> objDisp)
        {
            objDisposableObject = objDisp;
        }

        public void TestDispose()
        {
            int test = objDisposableObject.Count;

            if (test > 0)
            {
                foreach (var objName in objDisposableObject)
                {
                    Console.WriteLine(objName);
                    DisposeObject obj = new DisposeObject(objName);
                    obj.Dispose();
                }
            }
        }
    }

public class DisposeObject : IDisposable
    {
        bool disposed = false;
        object objToDispose = null;
        public DisposeObject(object objInstance)
        {
            objToDispose = objInstance;
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!disposed)
            {
                if (disposing)
                {
                    //dispose managed resources
                    /* Here i'm not able to Dispose the object 
                       i.e. objToDispose.Dispose(); */
                }
            }
            //dispose unmanaged resources
            //objToDispose = null;
            disposed = true;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(objToDispose);
        }
    }

public class Program
    {
        //Program objProgram = new Program();
        static void Main(string[] args)
        {
            Program obj = new Program();
            obj.FetchObjects(obj);
        }

        void FetchObjects(object objProgram)
        {
            List<object> lstTest = new List<object>();
            lstTest.Add(objProgram);
            Disposeable objDisposeable = new Disposeable(lstTest);
            objDisposeable.TestDispose();
        }
    }

代码按照我的预期执行。但是，无法达到我的预期。



我请你指导我。



谢谢你，

Sridharan

Code is executing as i expected. but, not able to achieve what i expected.

I request you to guide me with this.

Thank you,
Sridharan

推荐答案

你的父对象DisposeObject实现IDisposable的事实并不意味着它可以随后处理任何它内部引用。只有在* it *实现IDisposable时才能处理objToDispose。

The fact that your parent object DisposeObject implements IDisposable doesn't mean it can then dispose anything that it references internally. The "objToDispose" can only be disposed if *it* implements IDisposable as well.

protected virtual void Dispose(bool disposing)
{
    if (!disposed)
    {
        if (disposing && objToDispose is IDisposable)
        {
            ((IDisposable)objToDispose).Dispose();
        }
    }
    //dispose unmanaged resources
    //objToDispose = null;
    disposed = true;
}

void FetchObjects(object objProgram)
{
    List<object> lstTest = new List<object>();
    // program is not disposable
    lstTest.Add(objProgram);
            
    // SqlConnection is disposable
    lstTest.Add(new SqlConnection());

    Disposeable objDisposeable = new Disposeable(lstTest);
    objDisposeable.TestDispose();
}

此代码没有意义。你为什么要创建另一个对象只是为了摧毁另一个对象？



我不明白为什么你会做一个非常简单的复杂代码如果你使用的是 List< IDisposable> ，那么。



尽管migth是一种明智的用法考虑到问题和执行不力，我觉得这对你来说太先进了。



在做高级的东西之前你必须学习基础知识。否则，您的应用程序可能会崩溃，您将无法理解原因！

This code does not make sense. Why on earth would you create another object for the sole purpose of destroying another object?

I don't understand why you would do complicated code when it could be very simple if you were using a List<IDisposable> instead.

Although there migth be some sensible usage of that pattern, I think it is too advanced for you at that point given the question and the poor implementation.

Before doing advanced stuff you have to learn the basic. Otherwise, your application might just crash and you won't understand why!

这篇关于动态处理对象的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！