Caliburn.Micro, MVVM 기반 WPF

//Root폴더에 작성
using Caliburn.Micro;
using System;
using System.Collections.Generic;
using System.Windows;
using WPFUI.Helper;
using WPFUI.ViewModels;

namespace WPFUI
{
    public class Bootstrapper : BootstrapperBase
    {
        private readonly SimpleContainer simpleContainer = new SimpleContainer();

        public Bootstrapper()
        {
            Initialize();
        }

        protected override void OnStartup(object sender, StartupEventArgs e)
        {
            // 메인 윈도우 등록
            DisplayRootViewFor<ShellViewModel>();
        }

        protected override void Configure()
        {
            simpleContainer.Instance(simpleContainer);
            simpleContainer.Singleton<IWindowManager, WindowManager>().Singleton<IEventAggregator, EventAggregator>();

            // 이부분은 사용자 클래스(옵션)
            simpleContainer.Singleton<IMessageProvider, MessageProvider>();

            // 필요한 View(Window)를 싱글톤으로 등록
            simpleContainer.Singleton<ShellViewModel>();
            simpleContainer.Singleton<FirstViewModel>();
            simpleContainer.Singleton<SecondViewModel>();
            simpleContainer.Singleton<ThirdViewModel>();
        }

        protected override object GetInstance(Type service, string key)
        {
            return simpleContainer.GetInstance(service, key);
        }

        protected override IEnumerable<object> GetAllInstances(Type service)
        {
            return simpleContainer.GetAllInstances(service);
        }

        protected override void BuildUp(object instance)
        {
            simpleContainer.BuildUp(instance);
        }
    }
}

// ViewModels 폴더에 작성
using Caliburn.Micro;
using WPFUI.Helper;

namespace WPFUI.ViewModels
{
    public class ShellViewModel : Conductor<IScreen>.Collection.OneActive
    {
        private readonly IMessageProvider messageProvider;

        private string mTextBlockItemCount;

        public string TextBlockItemCount
        {
            get { return mTextBlockItemCount; }
            set
            {
                mTextBlockItemCount = value;
                NotifyOfPropertyChange(() => TextBlockItemCount);
            }
        }

        public ShellViewModel(IMessageProvider messageProvider)
        {
            this.messageProvider = messageProvider;
        }

        public string TitleMessage => messageProvider.Get();

        public void ButtonFirst()
        {
            ActiveItem = IoC.Get<FirstViewModel>();
        }

        public void ButtonSecond()
        {
            ActiveItem = IoC.Get<SecondViewModel>();
        }

        public void ButtonThird()
        {
            ActiveItem = IoC.Get<ThirdViewModel>();
        }

        public void ButtonItemCount()
        {
            TextBlockItemCount = Items.Count.ToString();
        }
    }
}

/***함수: GetPropertyDisplayName, FindChild, RefreshControl  
public string UserID => HelperUtils.GetPropertyDisplayName<FirstModel>(i => i.UserID);
Button btn = HelperUtils.FindChild<Button>(Application.Current.MainWindow, param.ToString());
btn.RefreshControl();
***/
namespace WPFUI.Helper
{
    public static class HelperUtils
    {
        public static T FindChild<T>(DependencyObject parent, string childName) where T : DependencyObject
        {
            if (parent == null) return null;
            T foundChild = null;
            int childrenCount = VisualTreeHelper.GetChildrenCount(parent);
            for (int i = 0; i < childrenCount; i++)
            {
                var child = VisualTreeHelper.GetChild(parent, i);
                T childType = child as T;
                if (childType == null)
                {
                    foundChild = FindChild<T>(child, childName);
                    if (foundChild != null) break;
                }
                else if (!string.IsNullOrEmpty(childName))
                {
                    var frameworkElement = child as FrameworkElement;
                    if (frameworkElement != null && frameworkElement.Name == childName)
                    {
                        foundChild = (T)child;
                        break;
                    }
                }
                else
                {
                    foundChild = (T)child;
                    break;
                }
            }
            return foundChild;
        }

        private static readonly Action EmptyDelegate = delegate { };

        public static void RefreshControl(this UIElement uiElement)
        {
            uiElement.Dispatcher.Invoke(DispatcherPriority.Render, EmptyDelegate);
        }

        public static T GetAttribute<T>(this MemberInfo member, bool isRequired) where T : Attribute
        {
            var attribute = member.GetCustomAttributes(typeof(T), false).SingleOrDefault();

            if (attribute == null && isRequired)
            {
                throw new ArgumentException(
                    string.Format(CultureInfo.InvariantCulture, "{0} 속성은 {1} 멤버에 정의되어야 합니다.", typeof(T).Name, member.Name));
            }

            return (T)attribute;
        }

        public static string GetPropertyDisplayName<T>(Expression<Func<T, object>> propertyExpression)
        {
            var memberInfo = GetPropertyInformation(propertyExpression.Body);
            if (memberInfo == null)
            {
                throw new ArgumentException("속성 참조 표현식이 없습니다.", "propertyExpression");
            }

            var attr = memberInfo.GetAttribute<DisplayNameAttribute>(false);
            if (attr == null)
            {
                return memberInfo.Name;
            }

            return attr.DisplayName;
        }

        public static MemberInfo GetPropertyInformation(System.Linq.Expressions.Expression propertyExpression)
        {
            Debug.Assert(propertyExpression != null, "propertyExpression != null");
            MemberExpression memberExpr = propertyExpression as MemberExpression;
            if (memberExpr == null)
            {
                if (propertyExpression is UnaryExpression unaryExpr && unaryExpr.NodeType == ExpressionType.Convert)
                {
                    memberExpr = unaryExpr.Operand as MemberExpression;
                }
            }

            if (memberExpr != null && memberExpr.Member.MemberType == MemberTypes.Property)
            {
                return memberExpr.Member;
            }

            return null;
        }
    }
}