ObsoleteAttributeとは？ わかりやすく解説

<SerializableAttribute> _
<ComVisibleAttribute(True)> _
<AttributeUsageAttribute(AttributeTargets.Class Or AttributeTargets.Struct
 Or AttributeTargets.Enum Or AttributeTargets.Constructor
 Or AttributeTargets.Method Or AttributeTargets.Property Or AttributeTargets.Field Or AttributeTargets.Event
 Or AttributeTargets.Interface Or AttributeTargets.Delegate, Inherited:=False)> _
Public NotInheritable Class
 ObsoleteAttribute
    Inherits Attribute

Dim instance As ObsoleteAttribute

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
[AttributeUsageAttribute(AttributeTargets.Class|AttributeTargets.Struct|AttributeTargets.Enum|AttributeTargets.Constructor|AttributeTargets.Method|AttributeTargets.Property|AttributeTargets.Field|AttributeTargets.Event|AttributeTargets.Interface|AttributeTargets.Delegate,
 Inherited=false)] 
public sealed class ObsoleteAttribute : Attribute

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
[AttributeUsageAttribute(AttributeTargets::Class|AttributeTargets::Struct|AttributeTargets::Enum|AttributeTargets::Constructor|AttributeTargets::Method|AttributeTargets::Property|AttributeTargets::Field|AttributeTargets::Event|AttributeTargets::Interface|AttributeTargets::Delegate,
 Inherited=false)] 
public ref class ObsoleteAttribute sealed :
 public Attribute

/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
/** @attribute AttributeUsageAttribute(AttributeTargets.Class|AttributeTargets.Struct|AttributeTargets.Enum|AttributeTargets.Constructor|AttributeTargets.Method|AttributeTargets.Property|AttributeTargets.Field|AttributeTargets.Event|AttributeTargets.Interface|AttributeTargets.Delegate,
 Inherited=false) */ 
public final class ObsoleteAttribute extends
 Attribute

SerializableAttribute 
ComVisibleAttribute(true) 
AttributeUsageAttribute(AttributeTargets.Class|AttributeTargets.Struct|AttributeTargets.Enum|AttributeTargets.Constructor|AttributeTargets.Method|AttributeTargets.Property|AttributeTargets.Field|AttributeTargets.Event|AttributeTargets.Interface|AttributeTargets.Delegate,
 Inherited=false) 
public final class ObsoleteAttribute extends
 Attribute

using System;

public sealed class App {
   static void Main() {      
      // The line below causes the compiler to issue a warning:
      // 'App.SomeDeprecatedMethod()' is obsolete: 'Do not call this
 method.'
      SomeDeprecatedMethod();
   }

   // The method below is marked with the ObsoleteAttribute. 
   // Any code that attempts to call this method will get a warning.
   [Obsolete("Do not call this method.")]
   private static void SomeDeprecatedMethod()
 { }
}

using namespace System;


// The method below is marked with the ObsoleteAttribute.
// Any code that attempts to call this method will get a warning.
[Obsolete("Do not call this method.")]
void SomeDeprecatedMethod()
{
}

int main()
{
    // The line below causes the compiler to issue a warning:
    // 'SomeDeprecatedMethod()': marked as obsolete
    // Message: 'Do not call this method.'
    SomeDeprecatedMethod();
}

Public Sub New

Dim instance As New ObsoleteAttribute

public ObsoleteAttribute ()

public:
ObsoleteAttribute ()

public ObsoleteAttribute ()

public function ObsoleteAttribute ()

Imports System

Public Class ObsoleteAttrib_Cons1
   ' Mark the method as 'Obsolete'.
   <ObsoleteAttribute()> Public Function
 OldFunction() As String
      Return "This is the String from old function."
   End Function 'OldFunction
   
   ' Create the another function which is replacement to the 'OldFunction'.
   Public Function NewFunction() As
 String
      Return "This is the String from new function."
   End Function 'NewFunction
End Class 'ObsoleteAttrib_Cons1

Public Class TestObsolete1
   'Entry point which delegates to C-style main Private Function
   Public Overloads Shared
 Sub Main()
      Main(System.Environment.GetCommandLineArgs())
   End Sub
   
   Overloads Shared Sub
 Main(args() As String)
      Try
         Dim myObsolete As New
 ObsoleteAttrib_Cons1()
         Console.WriteLine(myObsolete.OldFunction())
      Catch e As Exception
         Console.WriteLine(("The Exception is :" +
 e.Message))
      End Try
   End Sub 'Main
End Class 'TestObsolete1

using System;

public class ObsoleteAttrib_Cons1
{
   // Mark the method as 'Obsolete'.
   [ObsoleteAttribute()]
   public string OldFunction()
   {
      return "This is the String from old function.";
   }
   
// Create the another function which is replacement to the 'OldFunction'.
   public string NewFunction()
   {
      return "This is the String from new
 function.";
   }
}

public class TestObsolete1
{
   static void Main(string[]
 args)
   {         
      try
      {
         ObsoleteAttrib_Cons1 myObsolete = new ObsoleteAttrib_Cons1();
         Console.WriteLine(myObsolete.OldFunction());
      }
      catch(Exception e)
      {
         Console.WriteLine("The Exception is :"+e.Message);
      }
   }
}

using namespace System;
public ref class ObsoleteAttrib_Cons1
{
public:

   // Mark the method as 'Obsolete'.

   [Obsolete]
   String^ OldFunction()
   {
      return "This is the String from old function.";
   }


   // Create the another function which is replacement to the 'OldFunction'->
   String^ NewFunction()
   {
      return "This is the String from new
 function.";
   }

};

int main()
{
   try
   {
      ObsoleteAttrib_Cons1^ myObsolete = gcnew ObsoleteAttrib_Cons1;
      Console::WriteLine( myObsolete->OldFunction() );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "The Exception is : {0}", e->Message );
   }

}

import System.*;

public class ObsoleteAttrib_Cons1
{
    // Mark the method as 'Obsolete'.\

    /** @attribute ObsoleteAttribute()
     */
    public String OldFunction()
    {
        return "This is the String from old function.";
    } //OldFunction

    // Create the another function which is replacement to the 'OldFunction'.
    public String NewFunction()
    {
        return "This is the String from new
 function.";
    } //NewFunction
} //ObsoleteAttrib_Cons1

public class TestObsolete1
{
    public static void main(String[]
 args)
    {
        try {
            ObsoleteAttrib_Cons1 myObsolete = new ObsoleteAttrib_Cons1();
            Console.WriteLine(myObsolete.OldFunction());
        }
        catch (System.Exception e) {
            Console.WriteLine("The Exception is :" + e.get_Message());
        }
    } //main
} //TestObsolete1

Public Sub New ( _
    message As String, _
    error As Boolean _
)

Dim message As String
Dim error As Boolean

Dim instance As New ObsoleteAttribute(message,
 error)

public ObsoleteAttribute (
    string message,
    bool error
)

public:
ObsoleteAttribute (
    String^ message, 
    bool error
)

public ObsoleteAttribute (
    String message, 
    boolean error
)

public function ObsoleteAttribute (
    message : String, 
    error : boolean
)

Imports System

Public Class ObsoleteAttrib_Cons1
   ' Mark the method as 'Obsolete' with message and IsError as parameters.
   <ObsoleteAttribute("This function will be removed from
 future Versions.Use another function 'NewFunction'",
 False)> _
   Public Function OldFunction() As
 String
      OldFunction= "This is the String from old function."
   End Function 'OldFunction

   ' Create the another function which is replacement to the 'OldFunction'.
   Public Function NewFunction() As
 String
      Return "This is the String from new function."
   End Function 'NewFunction
End Class 'ObsoleteAttrib_Cons1

Public Class TestObsolete3
   'Entry point which delegates to C-style main Private Function
   Public Overloads Shared
 Sub Main()
      Main(System.Environment.GetCommandLineArgs())
   End Sub

   Overloads Shared Sub
 Main(args() As String)
      Try
         Dim myObsolete As New
 ObsoleteAttrib_Cons1()
         Console.WriteLine(myObsolete.OldFunction())
         Console.WriteLine(myObsolete.NewFunction())
      Catch e As Exception
         Console.WriteLine(("The Exception is :" +
 e.Message))
      End Try
   End Sub 'Main
End Class 'TestObsolete3

using System;

public class ObsoleteAttrib_Cons1
{

   // Mark the method as 'Obsolete' with message and IsError as parameters.
   [ObsoleteAttribute("This function will be removed from future Versions.Use
 another function 'NewFunction'",false)]
   public string OldFunction()
   {
      return "This is the String from old function.";
   }
   // Create the another function which is replacement to the 'OldFunction'.
   public string NewFunction()
   {
      return "This is the String from new
 function.";
   }

}
public class TestObsolete3
{
   static void Main(string[]
 args)
   {            
      try
      {
         ObsoleteAttrib_Cons1 myObsolete = new ObsoleteAttrib_Cons1();
         Console.WriteLine(myObsolete.OldFunction());
         Console.WriteLine(myObsolete.NewFunction());
      }
      catch(Exception e)
      {
         Console.WriteLine("The Exception is :"+e.Message);
      }
   }
}

using namespace System;
public ref class ObsoleteAttrib_Cons1
{
public:

   // Mark the method as 'Obsolete' with message and IsError as parameters.

   [ObsoleteAttribute("This function will be removed from future Versions. Use
 another function 'NewFunction'",false)]
   String^ OldFunction()
   {
      return "This is the String from old function.";
   }


   // Create another function which is replacement to the 'OldFunction'.
   String^ NewFunction()
   {
      return "This is the String from new
 function.";
   }

};

int main()
{
   try
   {
      ObsoleteAttrib_Cons1^ myObsolete = gcnew ObsoleteAttrib_Cons1;
      Console::WriteLine( myObsolete->OldFunction() );
      Console::WriteLine( myObsolete->NewFunction() );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "The Exception is : {0}", e->Message );
   }

}

import System.*;
public class ObsoleteAttrib_Cons1
{
    // Mark the method as 'Obsolete' with message and IsError as parameters.
    /** @attribute ObsoleteAttribute("This function will be removed from future"
       + "Versions.Use another function 'NewFunction'", false)
     */
    public String OldFunction()
    {
        return "This is the String from old function.";
    } //OldFunction

    // Create the another function which is replacement to the 'OldFunction'.
    public String NewFunction()
    {
        return "This is the String from new
 function.";
    } //NewFunction
} //ObsoleteAttrib_Cons1

public class TestObsolete3
{
    public static void main(String[]
 args)
    {
        try {
            ObsoleteAttrib_Cons1 myObsolete = new ObsoleteAttrib_Cons1();
            Console.WriteLine(myObsolete.OldFunction());
            Console.WriteLine(myObsolete.NewFunction());
        }
        catch (System.Exception e) {
            Console.WriteLine("The Exception is :" + e.get_Message());
        }
    } //main
} //TestObsolete3

Public Sub New ( _
    message As String _
)

Dim message As String

Dim instance As New ObsoleteAttribute(message)

public ObsoleteAttribute (
    string message
)

public:
ObsoleteAttribute (
    String^ message
)

public ObsoleteAttribute (
    String message
)

public function ObsoleteAttribute (
    message : String
)

Imports System

Public Class ObsoleteAttrib_Cons1
   ' Mark the method as 'Obsolete' with message as parameter.
   <ObsoleteAttribute("This function will be removed from
 future Versions.Use another function 'NewFunction'")>
 _
   Public Function OldFunction() As
 String
      OldFunction= "This is the String from old function."
   End Function 'OldFunction

   ' Create the another function which is replacement to the 'OldFunction'.
   Public Function NewFunction() As
 String
      NewFunction= "This is the String from new function."
   End Function 'NewFunction
End Class 'ObsoleteAttrib_Cons1

Public Class TestObsolete2
   'Entry point which delegates to C-style main Private Function
   Public Overloads Shared
 Sub Main()
      Main(System.Environment.GetCommandLineArgs())
   End Sub
   Overloads Shared Sub
 Main(args() As String)
      Try
         Dim myObsolete As New
 ObsoleteAttrib_Cons1()
         Console.WriteLine(myObsolete.OldFunction())
         Console.WriteLine(myObsolete.NewFunction())
      Catch e As Exception
         Console.WriteLine(("The Exception is :" +
 e.Message))
      End Try
   End Sub 'Main
End Class 'TestObsolete2

using System;
public class ObsoleteAttrib_Cons1
{
   // Mark the method as 'Obsolete' with message as parameter.
   [ObsoleteAttribute("This function will be removed from future Versions.Use
 another function 'NewFunction'")]
   public string OldFunction()
   {
      return "This is the String from old function.";
   }
   // Create the another function which is replacement to the 'OldFunction'.
   public string NewFunction()
   {
      return "This is the String from new
 function.";
   }
}

public class TestObsolete2
{
   static void Main(string[]
 args)
   {               
      try
      {
         ObsoleteAttrib_Cons1 myObsolete = new ObsoleteAttrib_Cons1();
         Console.WriteLine(myObsolete.OldFunction());
         Console.WriteLine(myObsolete.NewFunction());
      }
      catch(Exception e)
      {
         Console.WriteLine("The Exception is :"+e.Message);
      }
   }
}

using namespace System;
public ref class ObsoleteAttrib_Cons1
{
public:

   // Mark the method as 'Obsolete' with message as parameter.

   [ObsoleteAttribute("This function will be removed from future Versions. Use
 another function 'NewFunction'")]
   String^ OldFunction()
   {
      return "This is the String from old function.";
   }


   // Create another function which is replacement to the 'OldFunction'.
   String^ NewFunction()
   {
      return "This is the String from new
 function.";
   }

};

int main()
{
   try
   {
      ObsoleteAttrib_Cons1^ myObsolete = gcnew ObsoleteAttrib_Cons1;
      Console::WriteLine( myObsolete->OldFunction() );
      Console::WriteLine( myObsolete->NewFunction() );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "The Exception is : {0}", e->Message );
   }

}

import System.*;

public class ObsoleteAttrib_Cons1
{
    // Mark the method as 'Obsolete' with message as parameter.

    /** @attribute ObsoleteAttribute("This function will be removed from future"
        + "Versions.Use another function 'NewFunction'")
     */
    public String OldFunction()
    {
        return "This is the String from old function.";
    } //OldFunction

    // Create the another function which is replacement to the 'OldFunction'.
    public String NewFunction()
    {
        return "This is the String from new
 function.";
    } //NewFunction
} //ObsoleteAttrib_Cons1

public class TestObsolete2
{
    public static void main(String[]
 args)
    {
        try {
            ObsoleteAttrib_Cons1 myObsolete = new ObsoleteAttrib_Cons1();
            Console.WriteLine(myObsolete.OldFunction());
            Console.WriteLine(myObsolete.NewFunction());
        }
        catch (System.Exception e) {
            Console.WriteLine("The Exception is :" + e.get_Message());
        }
    } //main
} //TestObsolete2