탭 컨트롤에서 탭 페이지 숨기기 및 표시

탭 컨트롤에서 탭 페이지 숨기기 및 표시

사용자 선택에 따라 탭 페이지를 표시하거나 숨기려고 합니다.사용자가 성별 남성을 선택한 경우 "남성" 탭 페이지에 남성용 양식이 표시되어야 하며, 사용자가 여성을 선택한 경우 다음 탭 "여성"에도 유사한 다음 양식이 표시되어야 합니다.

사용해 보았습니다.

tabControl1.TabPages.Remove(...)

그리고.

tabControl1.TabPages.Add(...)

탭 페이지를 추가하거나 제거하지만 탭 페이지의 제어 기능도 해제됩니다.나는 그들을 다시 볼 수 없습니다.여기는 뭐가 문제인가요?

저는 답이 훨씬 더 쉽다고 생각합니다.

탭을 숨기려면 이미 시도한 방법을 사용하거나 탭 페이지 자체를 처리할 수 있습니다.

TabControl1.TabPages.Remove(TabPage1) 'Could be male
TabControl1.TabPages.Remove(TabPage2) 'Could be female

a.s.o.

탭 페이지를 제거해도 탭 페이지와 탭 페이지의 컨트롤이 파괴되지 않습니다.해당 탭을 다시 표시하려면 다음 코드를 사용하십시오.

TabControl1.TabPages.Insert(0, TabPage1) 'Show male
TabControl1.TabPages.Insert(1, TabPage2) 'Show female

탭 컨트롤에서 탭 페이지를 제거할 수 있습니다.TabPages 컬렉션을 목록에 저장합니다.예:

    private List<TabPage> hiddenPages = new List<TabPage>();

    private void EnablePage(TabPage page, bool enable) {
        if (enable) {
            tabControl1.TabPages.Add(page);
            hiddenPages.Remove(page);
        }
        else {
            tabControl1.TabPages.Remove(page);
            hiddenPages.Add(page);
        }
    }

    protected override void OnFormClosed(FormClosedEventArgs e) {
        foreach (var page in hiddenPages) page.Dispose();
        base.OnFormClosed(e);
    }

Hans Passant의 좋은 해결책을 개선하면서 나는 그의 해결책과 다른 것들을 추가하는 것을 기반으로 확장 방법을 쓰기로 결정했습니다..NET 4에서도 이 기본 기능이 수정되지 않은 것에 놀랐습니다.

• 보다 투명한 방식으로 재사용할 수 있는 확장 방법으로 구현
• 정리 방법은 삭제/정리 중인 컨트롤의 페이지만 정리합니다.
• 가능할 때마다 탭 페이지가 동일한 위치로 복원됩니다.여러 탭 페이지를 숨기거나 표시하는 경우 항상 가능한 것은 아닙니다.
• 일부 오류 및 매개 변수 확인을 수행합니다.
• 그것을 보이지 않게 하기 위해 그것은 부모를 찾습니다.표시할 때 탭 페이지가 제거되면 상위 속성이 null이므로 이 속성을 지정해야 합니다.

public static class TabPageExtensions
{
        private struct TabPageData
        {
            internal int Index;
            internal TabControl Parent;
            internal TabPage Page;

            internal TabPageData(int index, TabControl parent, TabPage page)
            {
                Index = index;
                Parent = parent;
                Page = page;
            }

            internal static string GetKey(TabControl tabCtrl, TabPage tabPage)
            {
                string key = "";
                if (tabCtrl != null && tabPage != null)
                {
                    key = String.Format("{0}:{1}", tabCtrl.Name, tabPage.Name);
                }
                return key;
            }
        }

        private static Dictionary<string, TabPageData> hiddenPages = new Dictionary<string, TabPageData>();

        public static void SetVisible(this TabPage page, TabControl parent)
        {
            if (parent != null && !parent.IsDisposed)
            {
                TabPageData tpinfo;

                string key = TabPageData.GetKey(parent, page);
                if (hiddenPages.ContainsKey(key))
                {
                    tpinfo = hiddenPages[key];
                    if (tpinfo.Index < parent.TabPages.Count)
                        parent.TabPages.Insert(tpinfo.Index, tpinfo.Page); // add the page in the same position it had
                    else
                        parent.TabPages.Add(tpinfo.Page);
                    hiddenPages.Remove(key);
                }
            }
        }

        public static void SetInvisible(this TabPage page)
        {
            if (IsVisible(page))
            {
                TabControl tabCtrl = (TabControl)page.Parent;
                TabPageData tpinfo;
                tpinfo = new TabPageData(tabCtrl.TabPages.IndexOf(page), tabCtrl, page);
                tabCtrl.TabPages.Remove(page);
                hiddenPages.Add(TabPageData.GetKey(tabCtrl, page), tpinfo);
            }
        }

        public static bool IsVisible(this TabPage page)
        {
            return page != null && page.Parent != null; // when Parent is null the tab page does not belong to any container
        }

        public static void CleanUpHiddenPages(this TabPage page)
        {
            foreach (TabPageData info in hiddenPages.Values)
            {
                if (info.Parent != null && info.Parent.Equals((TabControl)page.Parent))
                    info.Page.Dispose();
            }
        }

    }

다른 접근 방식으로는 두 개의 탭 컨트롤을 사용하여 하나는 표시하고 다른 하나는 표시하지 않는 것입니다.다음과 같이 탭을 이동할 수 있습니다(vb.net ).

If Me.chkShowTab1.Checked = True Then
    Me.tabsShown.TabPages.Add(Me.tabsHidden.TabPages("Tab1"))
    Me.tabsHidden.TabPages.RemoveByKey("Tab1")
Else
    Me.tabsHidden.TabPages.Add(Me.tabsShown.TabPages("Tab1"))
    Me.tabsShown.TabPages.RemoveByKey("Tab1")
End If

탭 순서가 중요한 경우 를 변경합니다.탭에 메서드 추가표시 대상.순서 위치를 삽입하고 지정합니다.이를 위한 한 가지 방법은 원하는 순서 위치를 반환하는 루틴을 호출하는 것입니다.

저는 평평한 스타일로 보이는 것을 선호합니다: https://stackoverflow.com/a/25192153/5660876

    tabControl1.Appearance = TabAppearance.FlatButtons;
    tabControl1.ItemSize = new Size(0, 1);
    tabControl1.SizeMode = TabSizeMode.Fixed;

그러나 모든 탭 페이지에 픽셀이 표시되므로 모든 탭 페이지의 텍스트를 모두 삭제하면 실행 시 탭이 완벽하게 보이지 않게 됩니다.

    foreach (TabPage tab in tabControl1.TabPages)
    {
        tab.Text = "";
    }

그런 다음 트리 보기를 사용하여 탭 페이지를 변경합니다.노드를 클릭합니다.

언제든지 탭 페이지를 숨기거나 표시할 수 있습니다.

'in VB
myTabControl.TabPages(9).Hide() 'to hide the tabpage that has index 9
myTabControl.TabPages(9).Show() 'to show the tabpage that has index 9

샘플 코드가 작동하지만 목록에서 탭을 좀 더 잘 참조할 수 있도록 하고 싶습니다.

Public Class Form1
    Dim State1 As Integer = 1
    Dim AllTabs As List(Of TabPage) = New List(Of TabPage)

    Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
        Check1(State1)
        State1 = CInt(IIf(State1 = 1, 0, 1))
    End Sub

    Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        AllTabs.Add(TabControl1.TabPages("TabPage1"))
        AllTabs.Add(TabControl1.TabPages("TabPage2"))
    End Sub

    Sub Check1(ByVal No As Integer)
        If TabControl1.TabPages.ContainsKey("TabPage1") Then
            TabControl1.TabPages.Remove(TabControl1.TabPages("TabPage1"))
        End If
        If TabControl1.TabPages.ContainsKey("TabPage2") Then
            TabControl1.TabPages.Remove(TabControl1.TabPages("TabPage2"))
        End If
        TabControl1.TabPages.Add(AllTabs(No))
    End Sub
End Class

    public static Action<Func<TabPage, bool>> GetTabHider(this TabControl container) {
        if (container == null) throw new ArgumentNullException("container");

        var orderedCache = new List<TabPage>();
        var orderedEnumerator = container.TabPages.GetEnumerator();
        while (orderedEnumerator.MoveNext()) {
            var current = orderedEnumerator.Current as TabPage;
            if (current != null) {
                orderedCache.Add(current);
            }
        }

        return (Func<TabPage, bool> where) => {
            if (where == null) throw new ArgumentNullException("where");

            container.TabPages.Clear();
            foreach (TabPage page in orderedCache) {
                if (where(page)) {
                    container.TabPages.Add(page);
                }
            }
        };
    }

다음과 같이 사용:

    var showOnly = this.TabContainer1.GetTabHider();
    showOnly((tab) => tab.Text != "tabPage1");

원래 순서는 익명 함수 인스턴스에 대한 참조를 유지하여 유지됩니다.

모든 탭 페이지를 지우고 원하는 항목을 추가하는 것이 더 쉬워 보입니다.

PropertyTabControl.TabPages.Clear();
        PropertyTabControl.TabPages.Add(AspectTabPage);
        PropertyTabControl.TabPages.Add(WerkstattTabPage);

또는

PropertyTabControl.TabPages.Clear();
        PropertyTabControl.TabPages.Add(TerminTabPage);

탭을 추가하거나 제거하는 것이 조금 덜 효과적일 수 있습니다. 이렇게 하면 도움이 될 수 있습니다.

탭 페이지를 숨기거나 표시하려면 => 탭을 누릅니다.탭 제어1의 페이지1

tapPage1.Parent = null;            //to hide tabPage1 from tabControl1
tabPage1.Parent = tabControl1;     //to show the tabPage1 in tabControl1

누군가가 C# 답변을 이 답변에 병합했기 때문에 여기에 답변을 게시해야 합니다.다른 솔루션이 마음에 들지 않아 탭 순서를 유지하면서 탭을 쉽게 숨기거나 표시할 수 있는 도우미 클래스를 만들었습니다.

/// <summary>
/// Memorizes the order of tabs upon creation to make hiding / showing tabs more
/// straightforward. Instead of interacting with the TabCollection, use this class
/// instead.
/// </summary>
public class TabPageHelper
{
    private List<TabPage> _allTabs;
    private TabControl.TabPageCollection _tabCollection;
    public Dictionary<string, int> TabOrder { get; private set; }

    public TabPageHelper( TabControl.TabPageCollection tabCollection )
    {
        _allTabs = new List<TabPage>();
        TabOrder = new Dictionary<string, int>();
        foreach ( TabPage tab in tabCollection )
        {
            _allTabs.Add( tab );
        }
        _tabCollection = tabCollection;
        foreach ( int index in Enumerable.Range( 0, tabCollection.Count ) )
        {
            var tab = tabCollection[index];
            TabOrder[tab.Name] = index;
        }
    }

    public void ShowTabPage( string tabText )
    {
        TabPage page = _allTabs
            .Where( t => string.Equals( t.Text, tabText, StringComparison.CurrentCultureIgnoreCase ) )
            .First();
        int tabPageOrder = TabOrder[page.Name];
        if ( !_tabCollection.Contains( page ) )
        {
            _tabCollection.Insert( tabPageOrder, page );
        }
    }

    public void HideTabPage( string tabText )
    {
        TabPage page = _allTabs
            .Where( t => string.Equals( t.Text, tabText, StringComparison.CurrentCultureIgnoreCase ) )
            .First();
        int tabPageOrder = TabOrder[page.Name];
        if ( _tabCollection.Contains( page ) )
        {
            _tabCollection.Remove( page );
        }
    }
}

클래스를 사용하려면 탭 컨트롤의 TabPages 속성을 전달하여 구성요소를 초기화한 후 폼 로드 방법으로 인스턴스화합니다.

public Form1()
{
    InitializeComponent();
    _tabHelper = new TabPageHelper( tabControl1.TabPages );
}

클래스는 숨기거나 표시할 때 탭 페이지의 순서를 기억하므로 모든 탭 페이지는 응용프로그램 로드(즉, 설계 보기)에 있어야 합니다.다음과 같이 프로그램 전체에서 선택적으로 숨기거나 표시할 수 있습니다.

_tabHelper.HideTabPage("Settings");
_tabHelper.ShowTabPage("Schedule");

숨겨진 TabPage를 개인 목록에 저장하는 것과 동일한 방법을 사용해 왔지만, 문제는 TabPage를 다시 표시하려고 할 때 원래 위치(순서)에 나타나지 않는다는 것입니다.그래서 마지막으로, 저는 두 가지 방법으로 TabControl을 추가하기 위해 VB로 수업을 작성했습니다.이름별 탭 페이지 및 이름별 탭 페이지 표시를 숨깁니다.TabPage 인스턴스가 아닌 이름을 전달하는 메서드만 호출할 수 있습니다.

Public Class CS_Control_TabControl
    Inherits System.Windows.Forms.TabControl

    Private mTabPagesHidden As New Dictionary(Of String, System.Windows.Forms.TabPage)
    Private mTabPagesOrder As List(Of String)

    Public Sub HideTabPageByName(ByVal TabPageName As String)
        If mTabPagesOrder Is Nothing Then
            ' The first time the Hide method is called, save the original order of the TabPages
            mTabPagesOrder = New List(Of String)
            For Each TabPageCurrent As TabPage In Me.TabPages
                mTabPagesOrder.Add(TabPageCurrent.Name)
            Next
        End If

        If Me.TabPages.ContainsKey(TabPageName) Then
            Dim TabPageToHide As TabPage

            ' Get the TabPage object
            TabPageToHide = TabPages(TabPageName)
            ' Add the TabPage to the internal List
            mTabPagesHidden.Add(TabPageName, TabPageToHide)
            ' Remove the TabPage from the TabPages collection of the TabControl
            Me.TabPages.Remove(TabPageToHide)
        End If
    End Sub

    Public Sub ShowTabPageByName(ByVal TabPageName As String)
        If mTabPagesHidden.ContainsKey(TabPageName) Then
            Dim TabPageToShow As TabPage

            ' Get the TabPage object
            TabPageToShow = mTabPagesHidden(TabPageName)
            ' Add the TabPage to the TabPages collection of the TabControl
            Me.TabPages.Insert(GetTabPageInsertionPoint(TabPageName), TabPageToShow)
            ' Remove the TabPage from the internal List
            mTabPagesHidden.Remove(TabPageName)
        End If
    End Sub

    Private Function GetTabPageInsertionPoint(ByVal TabPageName As String) As Integer
        Dim TabPageIndex As Integer
        Dim TabPageCurrent As TabPage
        Dim TabNameIndex As Integer
        Dim TabNameCurrent As String

        For TabPageIndex = 0 To Me.TabPages.Count - 1
            TabPageCurrent = Me.TabPages(TabPageIndex)
            For TabNameIndex = TabPageIndex To mTabPagesOrder.Count - 1
                TabNameCurrent = mTabPagesOrder(TabNameIndex)
                If TabNameCurrent = TabPageCurrent.Name Then
                    Exit For
                End If
                If TabNameCurrent = TabPageName Then
                    Return TabPageIndex
                End If
            Next
        Next
        Return TabPageIndex
    End Function

    Protected Overrides Sub Finalize()
        mTabPagesHidden = Nothing
        mTabPagesOrder = Nothing
        MyBase.Finalize()
    End Sub
End Class

    Public Shared HiddenTabs As New List(Of TabPage)()
Public Shared Visibletabs As New List(Of TabPage)()
Public Shared Function ShowTab(tab_ As TabPage, show_tab As Boolean)
    Select Case show_tab
        Case True
            If Visibletabs.Contains(tab_) = False Then Visibletabs.Add(tab_)
            If HiddenTabs.Contains(tab_) = True Then HiddenTabs.Remove(tab_)
        Case False
            If HiddenTabs.Contains(tab_) = False Then HiddenTabs.Add(tab_)
            If Visibletabs.Contains(tab_) = True Then Visibletabs.Remove(tab_)
    End Select
    For Each r In HiddenTabs
        Try
            Dim TC As TabControl = r.Parent
            If TC.Contains(r) = True Then TC.TabPages.Remove(r)
        Catch ex As Exception

        End Try
    Next
    For Each a In Visibletabs
        Try
            Dim TC As TabControl = a.Parent
            If TC.Contains(a) = False Then TC.TabPages.Add(a)
        Catch ex As Exception

        End Try
    Next
End Function

그리고 Emile(그리고 Slugster)의 답변을 바탕으로 TabControl(탭 페이지 대신)을 확장하는 것이 조금 더 쉽다는 것을 알게 되었습니다.이렇게 하면 한 번의 호출로 보이지 않는 페이지나 보이지 않는 페이지를 설정할 수 있으며 보이지 않는 페이지에 대한 null 부모 참조에 대해 걱정할 필요가 없습니다.

예: MyTabControl.탭 가시성 설정Ext("tabTests", 개발자);

public static class WinFormExtensions
{
    public static TabPage FindTabByNameExt( this TabControl tc, string tabName)
    {
        foreach (TabPage tab in tc.TabPages)
            if (tab.Name == tabName)
                return tab;

        return null;
    }

    private struct TabPageData
    {
        internal int Index;
        internal TabControl Parent;
        internal TabPage Page;

        internal TabPageData(int index, TabControl parent, TabPage page)
        {
            Index = index;
            Parent = parent;
            Page = page;
        }

        internal static string GetKey(TabControl tc, TabPage tabPage)
        {
            string key = "";
            if (tc == null || tabPage == null)
                return key;

            key = $"{tc.Name}:{tabPage.Name}";
            return key;
        }
        internal static string GetKey(TabControl tc, string tabName)
        {
            string key = "";
            if (tc == null)
                return key;

            key = $"{tc.Name}:{tabName}";
            return key;
        }
    }

    private static Dictionary<string, TabPageData> hiddenPages = new Dictionary<string, TabPageData>();

    public static void SetTabVisibleExt(this TabControl tc, string tabName)
    {
        if (tc == null || tc.IsDisposed)
            return;

        if (tc.IsTabVisibleExt(tabName))
            return;

        string key = TabPageData.GetKey(tc, tabName);
        if (hiddenPages.ContainsKey(key))
        {
            TabPageData tpinfo = hiddenPages[key];
            if (tpinfo.Index < tc.TabPages.Count)
                tc.TabPages.Insert(tpinfo.Index, tpinfo.Page); // add the page in the same position it had
            else
                tc.TabPages.Add(tpinfo.Page);

            hiddenPages.Remove(key);
            return;
        }
        else
            throw new ApplicationException($"TabControl={tc.Name} does not have Invisible TabPage={tabName}");
    }

    public static void SetTabInvisibleExt(this TabControl tc, string tabName)
    {
        if (tc == null || tc.IsDisposed)
            return;

        if (IsTabInvisibleExt(tc, tabName))
            return;

        TabPage page = tc.FindTabByNameExt(tabName);
        if (page != null)
        {
            string key = TabPageData.GetKey(tc, page);
            TabPageData tpInfo = new TabPageData(tc.TabPages.IndexOf(page), tc, page);
            tc.TabPages.Remove(page);
            hiddenPages.Add(key, tpInfo);
            return;
        }
        else // Could not find the tab, and it isn't already invisible.
            throw new ApplicationException($"TabControl={tc.Name} could not locate TabPage={tabName}");
    }

    // A convenience method to combine the SetTabInvisible and SetTabInvisible.
    public static void SetTabVisibilityExt(this TabControl tc, string tabName, bool? isVisible)
    {
        if (isVisible == null)
            return;

        if (isVisible.Value)
            tc.SetTabVisibleExt(tabName);
        else
            tc.SetTabInvisibleExt(tabName);
    }

    public static bool IsTabVisibleExt(this TabControl tc, string tabName)
    {
        TabPage page = tc.FindTabByNameExt(tabName);
        return page != null;
    }

    public static bool IsTabInvisibleExt(this TabControl tc, string tabName)
    {
        string key = TabPageData.GetKey(tc, tabName);
        return hiddenPages.ContainsKey(key);
    }

    public static void CleanUpHiddenPagesExt(this TabControl tc)
    {
        foreach (TabPageData info in hiddenPages.Values)
        {
            if (info.Parent != null && info.Parent.Equals((TabControl)tc))
                info.Page.Dispose();
        }
    }

}

만약 당신이 사용할 여유가 있다면.Tag의 TabPage할 수 .

    public static void HideByRemoval(this TabPage tp)
    {
        TabControl tc = tp.Parent as TabControl;

        if (tc != null && tc.TabPages.Contains(tp))
        {
            // Store TabControl and Index
            tp.Tag = new Tuple<TabControl, Int32>(tc, tc.TabPages.IndexOf(tp));
            tc.TabPages.Remove(tp);
        }
    }

    public static void ShowByInsertion(this TabPage tp)
    {
        Tuple<TabControl, Int32> tagObj = tp.Tag as Tuple<TabControl, Int32>;

        if (tagObj?.Item1 != null)
        {
            // Restore TabControl and Index
            tagObj.Item1.TabPages.Insert(tagObj.Item2, tp);
        }
    }

소프트웨어에서 솔루션을 코딩하는 방법은 적어도 두 가지가 있습니다.답변을 올려주셔서 감사합니다.다른 버전으로 업데이트하려고 합니다.TabPage 배열은 탭 컨트롤을 음영 처리하는 데 사용됩니다.로드 이벤트 중에 TabControl의 TabPages가 섀도 배열로 복사됩니다.나중에 이 섀도 배열은 탭 페이지를 탭 컨트롤에 복사하는 소스로 사용됩니다.원하는 프레젠테이션 순서로 표시합니다.

    Private tabControl1tabPageShadow() As TabPage = Nothing

    Private Sub Form2_DailyReportPackageViewer_Load(sender As Object, e As EventArgs) Handles Me.Load
        LoadTabPageShadow()
    End Sub


    Private Sub LoadTabPageShadow()
        ReDim tabControl1tabPageShadow(TabControl1.TabPages.Count - 1)
        For Each tabPage In TabControl1.TabPages
            tabControl1tabPageShadow(tabPage.TabIndex) = tabPage
        Next
    End Sub

    Private Sub ViewAllReports(sender As Object, e As EventArgs) Handles Button8.Click
        TabControl1.TabPages.Clear()
        For Each tabPage In tabControl1tabPageShadow
            TabControl1.TabPages.Add(tabPage)
        Next
    End Sub


    Private Sub ViewOperationsReports(sender As Object, e As EventArgs) Handles Button10.Click
        TabControl1.TabPages.Clear()

        For tabCount As Integer = 0 To 9
            For Each tabPage In tabControl1tabPageShadow
                Select Case tabPage.Text
                    Case "Overview"
                        If tabCount = 0 Then TabControl1.TabPages.Add(tabPage)
                    Case "Production Days Under 110%"
                        If tabCount = 1 Then TabControl1.TabPages.Add(tabPage)
                    Case "Screening Status"
                        If tabCount = 2 Then TabControl1.TabPages.Add(tabPage)
                    Case "Rework Status"
                        If tabCount = 3 Then TabControl1.TabPages.Add(tabPage)
                    Case "Secondary by Machine"
                        If tabCount = 4 Then TabControl1.TabPages.Add(tabPage)
                    Case "Secondary Set Ups"
                        If tabCount = 5 Then TabControl1.TabPages.Add(tabPage)
                    Case "Secondary Run Times"
                        If tabCount = 6 Then TabControl1.TabPages.Add(tabPage)
                    Case "Primary Set Ups"
                        If tabCount = 7 Then TabControl1.TabPages.Add(tabPage)
                    Case "Variance"
                        If tabCount = 8 Then TabControl1.TabPages.Add(tabPage)
                    Case "Schedule Changes"
                        If tabCount = 9 Then TabControl1.TabPages.Add(tabPage)
                End Select
            Next
        Next

안토니우스와 수로이가 제공한 해결책이 가장 간단합니다.Antony의 해결책에서 탭 페이지를 추가하기 전에 조건이 필요한지 여부.동일한 탭 페이지를 다시 추가하면 실제로 두 번째 탭 페이지가 추가되고 두 탭 페이지의 컨트롤이 제거됩니다.저는 제 앱에서 다음 코드를 사용했습니다.

   'Hide all the tabpages except Navigator during app startup.
        For Each itemTab As TabPage In TabControl1.TabPages
            If itemTab.Text <> "Navigator" Then
                TabControl1.TabPages.Remove(itemTab)
            End If
        Next 
    
    'Show the tab on button click
        If Not TabControl1.Controls.Contains(TabDataSource) Then
                TabControl1.TabPages.Add(TabDataSource)
            End If
            TabControl1.SelectedTab = TabDataSource

빠른 성능과 양호한 신뢰성을 위해 항상 코드는 간단하고 작업을 수행하기 쉬워야 합니다.

탭 컨트롤에 페이지를 추가하려면 다음 코드로 충분합니다.

If Tab control1.컨트롤.포함(탭페이지1)그리고나서
그렇지 않으면 Tabcontrol1.컨트롤.추가(탭페이지1) 종료 조건

탭 컨트롤에서 페이지를 제거하려면 다음 코드로 충분합니다.

If Tab control1.컨트롤.포함(탭페이지1)그런 다음 Tab control1.컨트롤.제거(TabPage1) 종료 조건

프로그래머들에게 진심으로 도움을 준 Stackoverflow.com 에 감사드립니다.

TabPanel1.Visible = true; // Show Tabpage 1
TabPanel1.Visible = false; //Hide Tabpage 1

먼저 탭을 변수에 복사한 다음 삽입을 사용하여 다시 가져옵니다.

TabPage tpresult = tabControl1.TabPages[0];
tabControl1.TabPages.RemoveAt(0);
tabControl1.TabPages.Insert(0, tpresult);

다음을 사용할 수 있습니다.

tabcontainer.tabs(1).visible=true

1은 탭 인덱스입니다.

언급URL : https://stackoverflow.com/questions/3365025/hiding-and-showing-tabpages-in-tabcontrol