如何手动释放对象，如何延长对象生命周期！--求助！！谢谢！！！

Question

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;namespace test4
{
class Program
{
public  class pepole
{ public string Name {get;set;}
public pepole(string n)
{ this.Name=n;}
}
static void Main(string[] args)
{
//问题1：
{
pepole Jim = new pepole("Jim");
Console.WriteLine(Jim.Name);
}//Jim 对象 在此处 结束生命 //如果这里调用  Console.WriteLine(Jim.Name);  则报错
//我想问问 如何骗过 C# 的垃圾收集器，不对Jim  对象的释放，而我想手动释放。（仅对Jim对象） //问题1： {
pepole Jim = new pepole("Jim");
Console.WriteLine(Jim.Name);
//如何在这里 释放 Jim 对象  //使得下面的
//Console.WriteLine(Jim.Name); 会报错呢

}//Jim 对象 在此处 结束生命


Console.ReadKey();
}
}
}

Answer 1

第一：pepole Jim；放在方法Main方法外部，作为Program的成员。第二：为何要手动释放?仅仅是为了不能让其调用方法？那就Jim=null;

Answer 2

对象实现IDisposable接口可以用using来强制清理

Answer 3

回1楼
我是 想动态搞链表！
不知怎样吧链表中间的一个节点DEL 了（老是出错，不是垃圾收集器把我的对象给释放了，就是只能静态声明，就像你说的那样，“把它声明在Main外”但这样可能会冲暴内存啊！）会得一定要支持一下啊----动态链表
下面是我的源代码，会的就点醒我吧！！！
谢谢啦!    //C# Code//
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;
    using System.Collections;    namespace test2
    {
            public class person        //测试用
            { public string Name { set; get; } }
            class Program
            {
                    static void Main(string[] args)
                    {
                            person p1 = new person();
                            p1.Name = "jim";
                            LinkedList MyList = new LinkedList();
                            MyList.AddLast(1);
                            MyList.AddLast("2");
                            MyList.AddLast(p1);
                            ListToScreen(MyList);        //输出
                            MyList.AddLast("Add");
                            MyList.AddLast(1000);
                            ListToScreen(MyList);        //输出                            MyList.PopLast();        //弹出一个元素
                            ListToScreen(MyList);        //输出
                            Console.ReadKey();
                    }
                    //---- 输出到LinkedList 所有元素屏幕的 ----
                    static void ListToScreen(LinkedList ll)
                    {
                            StringBuilder PutOut = new StringBuilder();        //输出到屏幕的String
                            foreach( var ob in ll )
                            {
                                    if( ob is string )
                                    {
                                            PutOut.Append(ob);
                                    }
                                    if( ob is person )
                                    {
                                            PutOut.Append(((person)ob).Name);
                                    }
                                    if( ob is int )
                                    {
                                            PutOut.Append(ob.ToString());
                                    }
                                    PutOut.Append("\t");
                            }
                            Console.WriteLine(PutOut);//执行输出
                    }
            }
            //定义数据节点1法
            public class LinkedListNode
            {
                    private object value;                        //data
                    public LinkedListNode(object value)        //构造
                    {
                            this.value = value;
                    }
                    public object Value
                    {
                            get { return value; }
                    }
                    private LinkedListNode next;
                    public LinkedListNode Next
                    {
                            get { return next; }
                            internal set { next = value; }
                    }
                    private LinkedListNode prev;
                    public LinkedListNode Prev
                    {
                            get { return prev; }
                            internal set { prev = value; }
                    }
                    LinkedListNode()
                    {
                            this.prev = this.next = null;
                    }
            }
            //定义链表 管理器
            public class LinkedList: IEnumerable
            {
                    private LinkedListNode current;        //本链尾节点
                    private LinkedListNode first;        //头节点
                    public LinkedListNode First
                    {
                            get { return first; }
                    }
                    private LinkedListNode last;        //本链尾节点
                    public LinkedListNode Last
                    {
                            get { return last; }
                    }
                    public bool CurrentMoveUp()        //当前节点上移
                    {
                            if( current == first )
                            {
                                    return false;
                            }
                            else
                            {
                                    current = current.Prev;
                            }
                            return true;
                    }
                    public bool CurrentMoveDown()        //当前节点下移
                    {
                            if( current == last )
                            {
                                    return false;
                            }
                            else
                            {
                                    current = current.Next;
                            }
                            return true;
                    }
                    public LinkedListNode AddLast(object node)//增加节点 -- 到最后
                    {
                            LinkedListNode newNode = new LinkedListNode(node);
                            if( first == null )        //
                            {
                                    first = newNode;
                                    last = first;
                                    current = first;
                            }
                            else
                            {
                                    this.last.Next = newNode;        // 链尾 连新结
                                    this.last = newNode;                // 链尾 重置
                            }
                            return newNode;
                    }
                    public LinkedListNode PopLast()                //取得最后一个节点，并且LinkedList 不去控制它
                    {
                            if( first == null )
                            {
                                    return null;
                            }
                            else
                            {
                                    LinkedListNode returnNode = last;        // 拿到链尾
                                    last = last.Prev;                        // 链尾 前移
                                    last.Next = null;                        // 链尾 打结     ///运行到这出错，谁知道为什么！！
                                    return returnNode;
                            }
                    }
                    //还没有增加删除方法
                    public IEnumerator GetEnumerator()        //专为 foreach 服务的
                    {
                            LinkedListNode current = first;//头节点
                            while( current != null )
                            {
                                    yield return current.Value;
                                    current = current.Next;
                            }
                    }
            }        
    }

Answer 4

结帖率：0.00%你把new 出来的东西都放到一个容器里面（链表，字典都可以，这个时候有指向对象的引用，所以系统不会回收），想手动清楚的时候在里面Remove掉，系统会帮你回收掉。
这个是解决办法之一

Answer 5

            else
            {
                this.last.Next = newNode; // 链尾 连新结 
                newNode.Prev = this.last;//你添加新节点是没有设置前面的节点，（ last = last.Prev;    ）导致last为null,你在调用last.Next肯定出问题
                this.last = newNode; // 链尾 重置 
            } 

Answer 6

ListToScreen这样写太繁琐了，我每添加一个新类型的元素你就要改一次，
可以利用重写添加元素的ToString()
 foreach (var ob in ll)
            {
                PutOut.Append(ob+"\t");
            } Console.WriteLine(PutOut);    public class person //测试用
    {
        public string Name { set; get; }
        public override string ToString()
        {
            return this.Name;
        }
    }

Answer 7

首先 感谢 NianHui(乱舞春秋)对我的帮助！
 你写的非常好，我能看明白你要表达的意思，
能让我体会到 重写ToString（） 的好处，
但是我还是不知到如何 删除链表的节点，（不是间单的剪短，连上，我想释放掉剪掉那段 的内存）。
比如下面的不知能不能展示一下你是
如何写PopLast（）方法？//PopLast--弹出最后一个节点，并删除它！

Answer 8

我就是在写一个这样的容器啊！----链表
[color=#80D00]现在正苦于写不出链表的删除方法！[/color]

Answer 9

你1L的问题和对象释放无关，那是一个变量作用域的问题
不能在后面访问Jim的原因是因为那里已经超出Jim这个变量（而不是对象）的作用域了，而不是Jim指向的对象被回收了什么的。你后面贴的那个代码
                    public LinkedListNode AddLast(object node)//增加节点 -- 到最后
                    {
                            LinkedListNode newNode = new LinkedListNode(node);
                            if( first == null )        //
                            {
                                    first = newNode;
                                    last = first;
                                    current = first;
                            }
                            else
                            {
                                    newNode.Prev=this.last; //少了这一句
                                    this.last.Next = newNode;        // 链尾 连新结
                                    this.last = newNode;                // 链尾 重置
                            }
                            return newNode;
                    }
添加新节点时你没有设置它的Prev属性，所以后面你last = last.Prev;的时候实际把last设为null了，然后last.Next自然会出错
你没有设置新节点的Prev属性，后面删除的时候你设置last=returnv

Answer 10

释放内存是gc的事情，你无法手动释放。虽然可以调用GC的一些方法让他去强制的释放，但是会增加相应的资源开销，还不如把它留给GC让GC去管理。

Answer 11

你把你所有new出来的对象都放到一个字典里面，需要的对象放到你自己的链表里面，这样每个对象都至少有一个引用了。从你的链表里面删除掉，但是字典里面还有引用，所以对象不会被回收。如果想手动删除，就在字典里面删除掉，它就没有引用了它就相当于手动回收了。

Answer 12

Alex__Su 实际上反复回答过这个问题，lz看来没有理会。不需要手动，因为对象被“释放”的原则很清晰。你把Jim 所引用的对象放到链表里，就不会“释放”。而一旦没有变量或者对象引用到它，比如说从链表里Remove掉这个对象，那么此垃圾就会自动被“释放”。

Answer 13

学 c 语言的纠结可见一斑。使用.net，你就尽量把精力放在开发应用系统上，底层纯粹计算机方面的东西是很自然地由系统完成的，你不用花大量精力纠结这类问题。

Answer 14

本人从C语言走来到.net 的  对.net 提供的方法有太多太多的不懂。
看到.net 提供的功能 难免会用C 的思维来分析它的实现原理，我也正想选打通链表再到树，矩形等数据结构， 由些深信不会数据结构写出项目必定困难重重。
加上我能力有限，到现在还搞不清接口是怎么回事。
特别是C++ 到C# 的继承方面，C#的类就没法同时继承两个类，没法保护继承等.自从接触.net 以来就没有 真正的深想编程的原理，逻辑和实现的可行性，代价（发时间多少），老是被它提供的方法搞得团团转，（不是Npoi 就是asp。net内的各种传参问题，特别是ListView）
你说我这种学习法方正常吗？
过来人支支招，谢谢啦！！

Answer 15

刚开车的人总是用一种不太正确的方式去感受汽车的各种配件，但不了解其组成并不影响你开车，封装的目的就是为了方便使用，如果有疑惑，最好办法是看书而不是瞎想和自己写例子猜测。有很多介绍clr和framework的书。我相信书名你是搜得到的，看书比瞎折腾来的直接。